| f | submodule Cisco-IOS-XR-mpls-te-oper-sub5 { | f | submodule Cisco-IOS-XR-mpls-te-oper-sub5 { |
| belongs-to Cisco-IOS-XR-mpls-te-oper { | | belongs-to Cisco-IOS-XR-mpls-te-oper { |
| prefix Cisco-IOS-XR-mpls-te-oper; | | prefix Cisco-IOS-XR-mpls-te-oper; |
| } | | } |
| | | |
| import ietf-inet-types { | | import ietf-inet-types { |
| prefix inet; | | prefix inet; |
| } | | } |
| import Cisco-IOS-XR-types { | | import Cisco-IOS-XR-types { |
| prefix xr; | | prefix xr; |
| } | | } |
| import cisco-semver { | | import cisco-semver { |
| prefix semver; | | prefix semver; |
| } | | } |
| include Cisco-IOS-XR-mpls-te-oper-sub6 { | | include Cisco-IOS-XR-mpls-te-oper-sub6 { |
| n | revision-date 2024-02-14; | n | revision-date 2021-08-09; |
| } | | } |
| | | |
| organization | | organization |
| "Cisco Systems, Inc."; | | "Cisco Systems, Inc."; |
| contact | | contact |
| "Cisco Systems, Inc. | | "Cisco Systems, Inc. |
| Customer Service | | Customer Service |
| | | |
| Postal: 170 West Tasman Drive | | Postal: 170 West Tasman Drive |
| San Jose, CA 95134 | | San Jose, CA 95134 |
| | | |
| Tel: +1 800 553-NETS | | Tel: +1 800 553-NETS |
| | | |
| E-mail: cs-yang@cisco.com"; | | E-mail: cs-yang@cisco.com"; |
| description | | description |
| "This submodule contains a collection of YANG definitions | | "This submodule contains a collection of YANG definitions |
| for Cisco IOS-XR mpls-te package operational data. | | for Cisco IOS-XR mpls-te package operational data. |
| | | |
| n | Copyright (c) 2013-2024 by Cisco Systems, Inc. | n | Copyright (c) 2013-2022 by Cisco Systems, Inc. |
| All rights reserved."; | | All rights reserved."; |
| | | |
| n | revision 2024-02-14 { | n | |
| description | | |
| "Added metric for forwarding adjacency | | |
| 2023-12-12 | | |
| Added auto-bw and soft-preemption to p2mp-te attribute-set | | |
| 2023-10-10 | | |
| Added source address to configured P2MP tunnel data | | |
| 2023-07-05 | | |
| Add knob to configure Autoroute Announce exclude all SR traffic | | |
| 2023-06-19 | | |
| Added flooding reason stats | | |
| 2023-04-24 | | |
| Add back TunnelAttributeSetStatic for backward compatibility | | |
| 2023-02-02 | | |
| Remove hidden commands | | |
| 2022-11-07 | | |
| Add TE++ over numbered tunnel feature | | |
| 2022-08-30 | | |
| Extending self-ping statistics bag | | |
| 2022-07-07 | | |
| Removed TunnelAttributeSetStatic from TunnelAttributeSetType | | |
| 2022-03-18 | | |
| Added self-ping under named-tunnels"; | | |
| semver:module-version "1.3.0"; | | |
| } | | |
| revision 2021-08-09 { | | revision 2021-08-09 { |
| description | | description |
| "Added load-interval attribute in the tunnel class. IosSetYangSchemaRev Cisco-IOS-XR-mpls-te-oper"; | | "Added load-interval attribute in the tunnel class. IosSetYangSchemaRev Cisco-IOS-XR-mpls-te-oper"; |
| semver:module-version "1.2.0"; | | semver:module-version "1.2.0"; |
| } | | } |
| revision 2021-01-19 { | | revision 2021-01-19 { |
| description | | description |
| "Added bandwidth-protection for auto-backups. Added signalled-bandwidth and soft-preemption for attribute set of autobackups. | | "Added bandwidth-protection for auto-backups. Added signalled-bandwidth and soft-preemption for attribute set of autobackups. |
| 2020-11-05 | | 2020-11-05 |
| n | Added secondary router id for TE nodes."; | n | Added secondary router id for TE nodes."; |
| semver:module-version "1.1.0"; | | semver:module-version "1.1.0"; |
| } | | } |
| revision 2020-03-28 { | | revision 2020-03-28 { |
| description | | description |
| "Added dark bandwidth accounting related oper info. Added stateful PCE static delegation related oper info. Added P2MP TE realted oper info. Added new operational leaves sim-rate-set sim-rate pce-address rewrite-lsd-queue tunnel-id-xr controller-handle backup-tunnel-sig-name protected-interface attribute-set-crc32 error delegation-status error context rewrite-lsd-queue simrate-enabled-in-last-application tunnel-id-xr p2mp-id-xr lsp-id-xr source-address-xr simrate-enabled-in-last-application is-expand-timer-running expand-timer-duration expand-timer-remain egress-interface-handle ingress-interface-handle srdb-check-enabled destination-create-time link-if-index create-time is-config-pending attribute-set-crc32 destination-list-crc32 maximum-destination-count maximum-tunnel-count srlg-number-xr tunnel-interface-name lsp-id-xr tunnel-rewrite-ctype tunnel-load-share tunnel-policy-class tunnel-forward-class lmp-is-allocated topology-node-igp-id topology-node-igp-area topology-node-is-router link-id classification-flags current-lsp-bandwidth-requested current-lsp-bandwidth-requested-type standby-lsp-bandwidth-requested standby-lsp-bandwidth-requested-type reopt-lsp-bandwidth-requested reopt-lsp-bandwidth-requested-type standby-reopt-lsp-bandwidth-requested standby-reopt-lsp-bandwidth-requested-type destination-address error tunnel-name-xr interface-name-xr interface-name"; | | "Added dark bandwidth accounting related oper info. Added stateful PCE static delegation related oper info. Added P2MP TE realted oper info. Added new operational leaves sim-rate-set sim-rate pce-address rewrite-lsd-queue tunnel-id-xr controller-handle backup-tunnel-sig-name protected-interface attribute-set-crc32 error delegation-status error context rewrite-lsd-queue simrate-enabled-in-last-application tunnel-id-xr p2mp-id-xr lsp-id-xr source-address-xr simrate-enabled-in-last-application is-expand-timer-running expand-timer-duration expand-timer-remain egress-interface-handle ingress-interface-handle srdb-check-enabled destination-create-time link-if-index create-time is-config-pending attribute-set-crc32 destination-list-crc32 maximum-destination-count maximum-tunnel-count srlg-number-xr tunnel-interface-name lsp-id-xr tunnel-rewrite-ctype tunnel-load-share tunnel-policy-class tunnel-forward-class lmp-is-allocated topology-node-igp-id topology-node-igp-area topology-node-is-router link-id classification-flags current-lsp-bandwidth-requested current-lsp-bandwidth-requested-type standby-lsp-bandwidth-requested standby-lsp-bandwidth-requested-type reopt-lsp-bandwidth-requested reopt-lsp-bandwidth-requested-type standby-reopt-lsp-bandwidth-requested standby-reopt-lsp-bandwidth-requested-type destination-address error tunnel-name-xr interface-name-xr interface-name"; |
| semver:module-version "1.0.0"; | | semver:module-version "1.0.0"; |
| } | | } |
| revision 2019-04-05 { | | revision 2019-04-05 { |
| description | | description |
| "Establish semantic version baseline."; | | "Establish semantic version baseline."; |
| semver:module-version "1.0.0"; | | semver:module-version "1.0.0"; |
| } | | } |
| revision 2018-08-01 { | | revision 2018-08-01 { |
| description | | description |
| "Removed empty groupings."; | | "Removed empty groupings."; |
| } | | } |
| revision 2017-09-07 { | | revision 2017-09-07 { |
| description | | description |
| "Fixed type translation error."; | | "Fixed type translation error."; |
| } | | } |
| revision 2017-05-01 { | | revision 2017-05-01 { |
| description | | description |
| "Fixing backward compatibility error in module."; | | "Fixing backward compatibility error in module."; |
| } | | } |
| revision 2015-11-09 { | | revision 2015-11-09 { |
| description | | description |
| "IOS XR 6.0 revision."; | | "IOS XR 6.0 revision."; |
| } | | } |
| | | |
| typedef Tunnel-state-enum { | | typedef Tunnel-state-enum { |
| type enumeration { | | type enumeration { |
| enum "tunnel-state-unknown" { | | enum "tunnel-state-unknown" { |
| description | | description |
| "No known state"; | | "No known state"; |
| } | | } |
| enum "new" { | | enum "new" { |
| description | | description |
| "Tunnel is new"; | | "Tunnel is new"; |
| } | | } |
| enum "preempting" { | | enum "preempting" { |
| description | | description |
| "Tunnel is being preempted"; | | "Tunnel is being preempted"; |
| } | | } |
| enum "admitting" { | | enum "admitting" { |
| description | | description |
| "Path being admitted"; | | "Path being admitted"; |
| } | | } |
| enum "half-admitted" { | | enum "half-admitted" { |
| description | | description |
| "Path was admitted partially and was then | | "Path was admitted partially and was then |
| rejected"; | | rejected"; |
| } | | } |
| enum "admitted" { | | enum "admitted" { |
| description | | description |
| "Path is already admitted successfully"; | | "Path is already admitted successfully"; |
| } | | } |
| enum "reservation-admitting" { | | enum "reservation-admitting" { |
| description | | description |
| "Reservation being admitted"; | | "Reservation being admitted"; |
| } | | } |
| enum "reservation-half-admitted" { | | enum "reservation-half-admitted" { |
| description | | description |
| "Reservation was admitted partially and was then | | "Reservation was admitted partially and was then |
| rejected"; | | rejected"; |
| } | | } |
| enum "reservation-admitted" { | | enum "reservation-admitted" { |
| description | | description |
| "Reservation is already admitted successfully"; | | "Reservation is already admitted successfully"; |
| } | | } |
| } | | } |
| description | | description |
| "Types of tunnel admission states"; | | "Types of tunnel admission states"; |
| } | | } |
| | | |
| typedef Bandwidth-state-enum { | | typedef Bandwidth-state-enum { |
| type enumeration { | | type enumeration { |
| enum "bandwidth-held" { | | enum "bandwidth-held" { |
| description | | description |
| "Bandwidth is held, is not guaranteed when it is | | "Bandwidth is held, is not guaranteed when it is |
| time to reserve"; | | time to reserve"; |
| } | | } |
| enum "bandwidth-reserved" { | | enum "bandwidth-reserved" { |
| description | | description |
| "Bandwidth is reserved and can be used for | | "Bandwidth is reserved and can be used for |
| forwarding"; | | forwarding"; |
| } | | } |
| enum "bandwidth-unknown" { | | enum "bandwidth-unknown" { |
| description | | description |
| "Bandwidth is unknown"; | | "Bandwidth is unknown"; |
| } | | } |
| } | | } |
| description | | description |
| "Types of bandwidth states"; | | "Types of bandwidth states"; |
| n | } | n | |
| | | |
| typedef Bandwidth-accounting-flooding-trigger { | | |
| type enumeration { | | |
| enum "bandwidth-threshold" { | | |
| description | | |
| "Flooding is triggered if bandwidth threshold is | | |
| crossed"; | | |
| } | | |
| enum "segment-routing-traffic" { | | |
| description | | |
| "Flooding is triggered if segment-routing | | |
| traffic change threshold is crossed"; | | |
| } | | |
| } | | |
| description | | |
| "Types of flooding triggers for bandwidth | | |
| accounting"; | | |
| } | | } |
| | | |
| typedef Bandwidth-accounting-collection { | | typedef Bandwidth-accounting-collection { |
| type enumeration { | | type enumeration { |
| enum "rsvp-te" { | | enum "rsvp-te" { |
| description | | description |
| "RSVP TE"; | | "RSVP TE"; |
| } | | } |
| enum "segment-routing" { | | enum "segment-routing" { |
| description | | description |
| "Segment Routing"; | | "Segment Routing"; |
| } | | } |
| } | | } |
| description | | description |
| "Types of bandwidth accounting collection"; | | "Types of bandwidth accounting collection"; |
| } | | } |
| | | |
| typedef Mpls-te-reason-not-flooded { | | typedef Mpls-te-reason-not-flooded { |
| type enumeration { | | type enumeration { |
| enum "not-flooded-reason-not-set" { | | enum "not-flooded-reason-not-set" { |
| description | | description |
| "reason not set"; | | "reason not set"; |
| } | | } |
| enum "controller-not-configured" { | | enum "controller-not-configured" { |
| description | | description |
| "Controller not configured"; | | "Controller not configured"; |
| } | | } |
| enum "controller-not-up" { | | enum "controller-not-up" { |
| description | | description |
| "Controller not up"; | | "Controller not up"; |
| } | | } |
| enum "no-local-link-id" { | | enum "no-local-link-id" { |
| description | | description |
| "Valid local link id is not populated"; | | "Valid local link id is not populated"; |
| } | | } |
| enum "no-remote-link-id" { | | enum "no-remote-link-id" { |
| description | | description |
| "Valid remote link id is not populated"; | | "Valid remote link id is not populated"; |
| } | | } |
| enum "odu-capabilities-not-set" { | | enum "odu-capabilities-not-set" { |
| description | | description |
| "ODU capabilities of link not set"; | | "ODU capabilities of link not set"; |
| } | | } |
| enum "tti-not-enabled" { | | enum "tti-not-enabled" { |
| description | | description |
| "TTI info for link is enabled"; | | "TTI info for link is enabled"; |
| } | | } |
| enum "link-not-supported" { | | enum "link-not-supported" { |
| description | | description |
| "This type of link is not suported"; | | "This type of link is not suported"; |
| } | | } |
| enum "te-proc-fsm-disabled" { | | enum "te-proc-fsm-disabled" { |
| description | | description |
| "Flooding disabled by TE process fsm"; | | "Flooding disabled by TE process fsm"; |
| } | | } |
| enum "graceful-shutdown" { | | enum "graceful-shutdown" { |
| description | | description |
| "Flooding diabled due to graceful shutdown"; | | "Flooding diabled due to graceful shutdown"; |
| } | | } |
| enum "flooding-disabled" { | | enum "flooding-disabled" { |
| description | | description |
| "Flooding is disabled"; | | "Flooding is disabled"; |
| } | | } |
| enum "label-switch-fabric-disabled" { | | enum "label-switch-fabric-disabled" { |
| description | | description |
| "Label switching fabric is disabled"; | | "Label switching fabric is disabled"; |
| } | | } |
| enum "no-igp-area-config" { | | enum "no-igp-area-config" { |
| description | | description |
| "No IGP area is configured"; | | "No IGP area is configured"; |
| } | | } |
| enum "area-not-configured" { | | enum "area-not-configured" { |
| description | | description |
| "Area is not configured"; | | "Area is not configured"; |
| } | | } |
| enum "area-not-ready" { | | enum "area-not-ready" { |
| description | | description |
| "Area is not ready for flood"; | | "Area is not ready for flood"; |
| } | | } |
| enum "lsa-error" { | | enum "lsa-error" { |
| description | | description |
| "Failure occured while building LSA"; | | "Failure occured while building LSA"; |
| } | | } |
| enum "igp-failed" { | | enum "igp-failed" { |
| description | | description |
| "IGP failed"; | | "IGP failed"; |
| } | | } |
| enum "flooding-requested" { | | enum "flooding-requested" { |
| description | | description |
| "Link is ready to flood and requested for | | "Link is ready to flood and requested for |
| flooding"; | | flooding"; |
| } | | } |
| enum "link-flooded" { | | enum "link-flooded" { |
| description | | description |
| "Link is flooded"; | | "Link is flooded"; |
| } | | } |
| } | | } |
| description | | description |
| "Reason why TE link is not flooded"; | | "Reason why TE link is not flooded"; |
| } | | } |
| | | |
| typedef Tti-mode { | | typedef Tti-mode { |
| type enumeration { | | type enumeration { |
| enum "none" { | | enum "none" { |
| value 0; | | value 0; |
| description | | description |
| "None"; | | "None"; |
| } | | } |
| enum "otu-secion-monitoring" { | | enum "otu-secion-monitoring" { |
| value 1; | | value 1; |
| description | | description |
| "Section Monitoring"; | | "Section Monitoring"; |
| } | | } |
| enum "odu-path-monitoring" { | | enum "odu-path-monitoring" { |
| value 2; | | value 2; |
| description | | description |
| "Path Monitoring"; | | "Path Monitoring"; |
| } | | } |
| enum "odu-tandem-connection-monitoring" { | | enum "odu-tandem-connection-monitoring" { |
| value 3; | | value 3; |
| description | | description |
| "Tandem Connection"; | | "Tandem Connection"; |
| } | | } |
| } | | } |
| description | | description |
| "GMPLS TTI Mode for controller"; | | "GMPLS TTI Mode for controller"; |
| } | | } |
| | | |
| typedef Bandwidth-type-enum { | | typedef Bandwidth-type-enum { |
| type enumeration { | | type enumeration { |
| enum "pool0" { | | enum "pool0" { |
| description | | description |
| "Bandwidth from the pool0"; | | "Bandwidth from the pool0"; |
| } | | } |
| enum "pool1" { | | enum "pool1" { |
| description | | description |
| "Pool1 bandwidth"; | | "Pool1 bandwidth"; |
| } | | } |
| enum "unknown" { | | enum "unknown" { |
| description | | description |
| "Unknown Bandwidth"; | | "Unknown Bandwidth"; |
| } | | } |
| } | | } |
| description | | description |
| "Types of bandwidth pools"; | | "Types of bandwidth pools"; |
| } | | } |
| | | |
| typedef Admission-policy { | | typedef Admission-policy { |
| type enumeration { | | type enumeration { |
| enum "reject-all" { | | enum "reject-all" { |
| description | | description |
| "Deprecated"; | | "Deprecated"; |
| } | | } |
| enum "allow-all" { | | enum "allow-all" { |
| description | | description |
| "Deprecated"; | | "Deprecated"; |
| } | | } |
| enum "reject-huge" { | | enum "reject-huge" { |
| description | | description |
| "Deprecated"; | | "Deprecated"; |
| } | | } |
| enum "allow-if-room" { | | enum "allow-if-room" { |
| description | | description |
| "Deprecated"; | | "Deprecated"; |
| } | | } |
| } | | } |
| description | | description |
| "Deprecated"; | | "Deprecated"; |
| } | | } |
| | | |
| typedef Signaling-agent-enum { | | typedef Signaling-agent-enum { |
| type enumeration { | | type enumeration { |
| enum "no-signaling" { | | enum "no-signaling" { |
| description | | description |
| "Deprecated - No signaling protocol configured"; | | "Deprecated - No signaling protocol configured"; |
| } | | } |
| enum "rsvp-signaling" { | | enum "rsvp-signaling" { |
| description | | description |
| "Deprecated - RSVP is the signaling protocol"; | | "Deprecated - RSVP is the signaling protocol"; |
| } | | } |
| } | | } |
| description | | description |
| "Deprecated - Signaling Agent"; | | "Deprecated - Signaling Agent"; |
| } | | } |
| | | |
| typedef Resource-provider { | | typedef Resource-provider { |
| type enumeration { | | type enumeration { |
| enum "resource-provider-none" { | | enum "resource-provider-none" { |
| description | | description |
| "Unknown"; | | "Unknown"; |
| } | | } |
| enum "packet-switch-capable" { | | enum "packet-switch-capable" { |
| description | | description |
| "Packet Switch Capable"; | | "Packet Switch Capable"; |
| } | | } |
| enum "time-division-multiplex" { | | enum "time-division-multiplex" { |
| description | | description |
| "TDM - SONET/SDH"; | | "TDM - SONET/SDH"; |
| } | | } |
| enum "lambda-switch-capable" { | | enum "lambda-switch-capable" { |
| description | | description |
| "Lambda Switch Capable"; | | "Lambda Switch Capable"; |
| } | | } |
| enum "fiber-switch-capable" { | | enum "fiber-switch-capable" { |
| description | | description |
| "Fiber Switch Capable"; | | "Fiber Switch Capable"; |
| } | | } |
| enum "g709odu-capable" { | | enum "g709odu-capable" { |
| description | | description |
| "Resource provider of type G709-ODU"; | | "Resource provider of type G709-ODU"; |
| } | | } |
| } | | } |
| description | | description |
| "The resource provider type"; | | "The resource provider type"; |
| } | | } |
| | | |
| typedef Link-direction-enum { | | typedef Link-direction-enum { |
| type enumeration { | | type enumeration { |
| enum "link-direction-up-stream" { | | enum "link-direction-up-stream" { |
| description | | description |
| "Upstream direction, Tail to Head"; | | "Upstream direction, Tail to Head"; |
| } | | } |
| enum "link-direction-down-stream" { | | enum "link-direction-down-stream" { |
| description | | description |
| "Upstream direction, Head to Tail"; | | "Upstream direction, Head to Tail"; |
| } | | } |
| enum "link-direction-unknown" { | | enum "link-direction-unknown" { |
| description | | description |
| "Unknown direction"; | | "Unknown direction"; |
| } | | } |
| } | | } |
| description | | description |
| "Link direction types"; | | "Link direction types"; |
| } | | } |
| | | |
| typedef Bandwidth-unit-enum { | | typedef Bandwidth-unit-enum { |
| type enumeration { | | type enumeration { |
| enum "kilo-bits-per-second" { | | enum "kilo-bits-per-second" { |
| description | | description |
| "kilobits per second"; | | "kilobits per second"; |
| } | | } |
| enum "kilo-bytes-per-second" { | | enum "kilo-bytes-per-second" { |
| description | | description |
| "kilobytes per second"; | | "kilobytes per second"; |
| } | | } |
| } | | } |
| description | | description |
| "Types of bandwidth units"; | | "Types of bandwidth units"; |
| } | | } |
| | | |
| typedef Flooding-trigger { | | typedef Flooding-trigger { |
| type enumeration { | | type enumeration { |
| enum "flooding-reason-unknown" { | | enum "flooding-reason-unknown" { |
| description | | description |
| "Not known what caused flooding"; | | "Not known what caused flooding"; |
| } | | } |
| enum "link-up" { | | enum "link-up" { |
| description | | description |
| "TE link came Up"; | | "TE link came Up"; |
| } | | } |
| enum "link-down" { | | enum "link-down" { |
| description | | description |
| "TE link went Down"; | | "TE link went Down"; |
| } | | } |
| enum "threshold-up" { | | enum "threshold-up" { |
| description | | description |
| "Up threshold crossed in pool0"; | | "Up threshold crossed in pool0"; |
| } | | } |
| enum "threshold-down" { | | enum "threshold-down" { |
| description | | description |
| "Down threshold crossed in pool0"; | | "Down threshold crossed in pool0"; |
| } | | } |
| enum "threshold-up-pool1" { | | enum "threshold-up-pool1" { |
| description | | description |
| "Up threshold crossed in pool1"; | | "Up threshold crossed in pool1"; |
| } | | } |
| enum "threshold-down-pool1" { | | enum "threshold-down-pool1" { |
| description | | description |
| "Down threshold crossed in pool1"; | | "Down threshold crossed in pool1"; |
| } | | } |
| enum "timer-expired" { | | enum "timer-expired" { |
| description | | description |
| "Periodic timer expired"; | | "Periodic timer expired"; |
| } | | } |
| enum "bandwidth-change" { | | enum "bandwidth-change" { |
| description | | description |
| "Link BW changed"; | | "Link BW changed"; |
| } | | } |
| enum "user" { | | enum "user" { |
| description | | description |
| "User triggered flooding"; | | "User triggered flooding"; |
| } | | } |
| enum "rsvp-timeout" { | | enum "rsvp-timeout" { |
| description | | description |
| "RSVP timed out"; | | "RSVP timed out"; |
| } | | } |
| enum "rsvp-reconnect" { | | enum "rsvp-reconnect" { |
| description | | description |
| "RSVP reconnected"; | | "RSVP reconnected"; |
| } | | } |
| enum "te-exited" { | | enum "te-exited" { |
| description | | description |
| "TE-control process exited"; | | "TE-control process exited"; |
| } | | } |
| enum "srlg-change" { | | enum "srlg-change" { |
| description | | description |
| "Link SRLG changed"; | | "Link SRLG changed"; |
| } | | } |
| enum "hw-oor-green" { | | enum "hw-oor-green" { |
| description | | description |
| "HW resources are green"; | | "HW resources are green"; |
| } | | } |
| enum "hw-oor-yellow" { | | enum "hw-oor-yellow" { |
| description | | description |
| "HW resources are yellow"; | | "HW resources are yellow"; |
| } | | } |
| enum "hw-oor-red" { | | enum "hw-oor-red" { |
| description | | description |
| "HW resources are red"; | | "HW resources are red"; |
| } | | } |
| enum "hw-oor-recovery-duration-expired" { | | enum "hw-oor-recovery-duration-expired" { |
| description | | description |
| "HW Resources are back to normal and the | | "HW Resources are back to normal and the |
| transition period is over"; | | transition period is over"; |
| } | | } |
| enum "lsp-oor-green" { | | enum "lsp-oor-green" { |
| description | | description |
| "LSP resources are green"; | | "LSP resources are green"; |
| } | | } |
| enum "lsp-oor-yellow" { | | enum "lsp-oor-yellow" { |
| description | | description |
| "LSP resources are yellow"; | | "LSP resources are yellow"; |
| } | | } |
| enum "lsp-oor-red" { | | enum "lsp-oor-red" { |
| description | | description |
| "LSP resources are red"; | | "LSP resources are red"; |
| } | | } |
| enum "lsp-oor-recovery-duration-expired" { | | enum "lsp-oor-recovery-duration-expired" { |
| description | | description |
| "LSP resources are back to normal and the | | "LSP resources are back to normal and the |
| transition period is over"; | | transition period is over"; |
| } | | } |
| enum "max-res-bandwidth-threshold-up" { | | enum "max-res-bandwidth-threshold-up" { |
| description | | description |
| "Max reservable bandwidth up threshold crossed"; | | "Max reservable bandwidth up threshold crossed"; |
| } | | } |
| enum "max-res-bandwidth-threshold-down" { | | enum "max-res-bandwidth-threshold-down" { |
| description | | description |
| "Max reservable bandwidth down threshold crossed"; | | "Max reservable bandwidth down threshold crossed"; |
| } | | } |
| n | enum "segment-routing-traffic" { | n | |
| description | | |
| "Segment-routing traffic change percentage | | |
| crossed"; | | |
| } | | |
| enum "lsp-bandwidth-admission-rejection" { | | |
| description | | |
| "LSP bandwidth admission rejected"; | | |
| } | | |
| enum "last-flooding-trigger" { | | |
| description | | |
| "Used to count the triggers, it is never used as | | |
| an actual trigger"; | | |
| } | | |
| } | | } |
| description | | description |
| "Types of flooding triggers"; | | "Types of flooding triggers"; |
| } | | } |
| | | |
| typedef Te-auto-tun-exp-path-hop { | | typedef Te-auto-tun-exp-path-hop { |
| type enumeration { | | type enumeration { |
| enum "ipv4-address-type" { | | enum "ipv4-address-type" { |
| description | | description |
| "IPv4 Address Type"; | | "IPv4 Address Type"; |
| } | | } |
| enum "mpls-label-type" { | | enum "mpls-label-type" { |
| description | | description |
| "MPLS Label Type"; | | "MPLS Label Type"; |
| } | | } |
| enum "ipv4-and-label-type" { | | enum "ipv4-and-label-type" { |
| description | | description |
| "IPv4 Address and MPLS Label Type"; | | "IPv4 Address and MPLS Label Type"; |
| } | | } |
| } | | } |
| description | | description |
| "Auto tunnel hop type"; | | "Auto tunnel hop type"; |
| } | | } |
| | | |
| typedef In-addr-ipv6 { | | typedef In-addr-ipv6 { |
| type inet:ipv6-address; | | type inet:ipv6-address; |
| description | | description |
| "In addr ipv6"; | | "In addr ipv6"; |
| } | | } |
| | | |
| typedef Lsp-oor-state { | | typedef Lsp-oor-state { |
| type enumeration { | | type enumeration { |
| enum "lsp-oor-green" { | | enum "lsp-oor-green" { |
| description | | description |
| "LSP numbers are in normal state"; | | "LSP numbers are in normal state"; |
| } | | } |
| enum "lsp-oor-yellow" { | | enum "lsp-oor-yellow" { |
| description | | description |
| "LSP numbers exceed the minor threshold"; | | "LSP numbers exceed the minor threshold"; |
| } | | } |
| enum "lsp-oor-red" { | | enum "lsp-oor-red" { |
| description | | description |
| "LSP numbers exceed the major threshold"; | | "LSP numbers exceed the major threshold"; |
| } | | } |
| } | | } |
| description | | description |
| "LSP OOR states"; | | "LSP OOR states"; |
| } | | } |
| | | |
| typedef Te-s2l-output-rw-explicit-null { | | typedef Te-s2l-output-rw-explicit-null { |
| type enumeration { | | type enumeration { |
| enum "tes2l-output-rw-exp-null" { | | enum "tes2l-output-rw-exp-null" { |
| value 0; | | value 0; |
| description | | description |
| "No explicit null imposed"; | | "No explicit null imposed"; |
| } | | } |
| enum "tes2l-output-rw-exp-null-v4" { | | enum "tes2l-output-rw-exp-null-v4" { |
| value 1; | | value 1; |
| description | | description |
| "IPv4 explicit null imposed"; | | "IPv4 explicit null imposed"; |
| } | | } |
| enum "tes2l-output-rw-exp-null-v6" { | | enum "tes2l-output-rw-exp-null-v6" { |
| value 2; | | value 2; |
| description | | description |
| "IPv6 explicit null imposed"; | | "IPv6 explicit null imposed"; |
| } | | } |
| } | | } |
| description | | description |
| "Explicit-null type"; | | "Explicit-null type"; |
| } | | } |
| | | |
| typedef Mpls-te-tunnels-process-status { | | typedef Mpls-te-tunnels-process-status { |
| type enumeration { | | type enumeration { |
| enum "not-running" { | | enum "not-running" { |
| description | | description |
| "MPLS TE process is not running"; | | "MPLS TE process is not running"; |
| } | | } |
| enum "running" { | | enum "running" { |
| description | | description |
| "MPLS TE process is running"; | | "MPLS TE process is running"; |
| } | | } |
| enum "not-registered-with-rsvp" { | | enum "not-registered-with-rsvp" { |
| description | | description |
| "MPLS TE process has not registered with RSVP"; | | "MPLS TE process has not registered with RSVP"; |
| } | | } |
| } | | } |
| description | | description |
| "Mpls te tunnels process status"; | | "Mpls te tunnels process status"; |
| } | | } |
| | | |
| typedef Mpls-te-frr-sharing { | | typedef Mpls-te-frr-sharing { |
| type enumeration { | | type enumeration { |
| enum "sharing-none" { | | enum "sharing-none" { |
| description | | description |
| "No Fate Sharing"; | | "No Fate Sharing"; |
| } | | } |
| enum "sharing-pri-oi-backup-oi-parent" { | | enum "sharing-pri-oi-backup-oi-parent" { |
| description | | description |
| "Primary Sharing outgoing interface with the | | "Primary Sharing outgoing interface with the |
| Parent of the backup outgoing interface"; | | Parent of the backup outgoing interface"; |
| } | | } |
| enum "sharing-pri-oi-parent-backup-oi" { | | enum "sharing-pri-oi-parent-backup-oi" { |
| description | | description |
| "Primary Sharing Parent of the outgoing | | "Primary Sharing Parent of the outgoing |
| interface with the backup outgoing interface"; | | interface with the backup outgoing interface"; |
| } | | } |
| enum "sharing-pri-oi-parent-backup-oi-parent" { | | enum "sharing-pri-oi-parent-backup-oi-parent" { |
| description | | description |
| "Primary Sharing Parent of the outgoing | | "Primary Sharing Parent of the outgoing |
| interface with the Parent of the backup | | interface with the Parent of the backup |
| outgoing interface"; | | outgoing interface"; |
| } | | } |
| } | | } |
| description | | description |
| "FRR sharing type"; | | "FRR sharing type"; |
| } | | } |
| | | |
| typedef Mpls-te-bw-limit { | | typedef Mpls-te-bw-limit { |
| type enumeration { | | type enumeration { |
| enum "bandwidth-limited" { | | enum "bandwidth-limited" { |
| description | | description |
| "Bandwidth is limited"; | | "Bandwidth is limited"; |
| } | | } |
| enum "bandwidth-unlimited" { | | enum "bandwidth-unlimited" { |
| description | | description |
| "Bandwidth is unlimited"; | | "Bandwidth is unlimited"; |
| } | | } |
| enum "bandwidth-none" { | | enum "bandwidth-none" { |
| description | | description |
| "Bandwidth is None"; | | "Bandwidth is None"; |
| } | | } |
| } | | } |
| description | | description |
| "Bandwidth limit type"; | | "Bandwidth limit type"; |
| } | | } |
| | | |
| typedef Mpls-te-backup-usage { | | typedef Mpls-te-backup-usage { |
| type enumeration { | | type enumeration { |
| enum "backup-not-protecting" { | | enum "backup-not-protecting" { |
| description | | description |
| "Backup is not protecting any LSP"; | | "Backup is not protecting any LSP"; |
| } | | } |
| enum "backup-protecting" { | | enum "backup-protecting" { |
| description | | description |
| "Backup is protecting at least one LSP"; | | "Backup is protecting at least one LSP"; |
| } | | } |
| } | | } |
| description | | description |
| "FRR backup tunnel usage status"; | | "FRR backup tunnel usage status"; |
| } | | } |
| | | |
| typedef Mpls-te-backup { | | typedef Mpls-te-backup { |
| type enumeration { | | type enumeration { |
| enum "backup-static" { | | enum "backup-static" { |
| description | | description |
| "Backup type is static"; | | "Backup type is static"; |
| } | | } |
| enum "backup-auto" { | | enum "backup-auto" { |
| description | | description |
| "Backup type is auto-tunnel"; | | "Backup type is auto-tunnel"; |
| } | | } |
| } | | } |
| description | | description |
| "FRR backup tunnel type"; | | "FRR backup tunnel type"; |
| } | | } |
| | | |
| typedef Mpls-te-backup-status { | | typedef Mpls-te-backup-status { |
| type enumeration { | | type enumeration { |
| enum "backup-none" { | | enum "backup-none" { |
| description | | description |
| "Backup not found"; | | "Backup not found"; |
| } | | } |
| enum "backup-unused" { | | enum "backup-unused" { |
| description | | description |
| "Backup status undefined"; | | "Backup status undefined"; |
| } | | } |
| enum "backup-next-next-hop" { | | enum "backup-next-next-hop" { |
| description | | description |
| "Backup is next next hop safe (node protection)"; | | "Backup is next next hop safe (node protection)"; |
| } | | } |
| enum "backup-next-hop" { | | enum "backup-next-hop" { |
| description | | description |
| "Backup is next hop safe (link protection)"; | | "Backup is next hop safe (link protection)"; |
| } | | } |
| enum "backup-next-next-hop-srlg" { | | enum "backup-next-next-hop-srlg" { |
| description | | description |
| "Backup is next next hop and SRLG safe (node | | "Backup is next next hop and SRLG safe (node |
| protection)"; | | protection)"; |
| } | | } |
| enum "backup-next-hop-srlg" { | | enum "backup-next-hop-srlg" { |
| description | | description |
| "Backup is next hop and SRLG safe (link | | "Backup is next hop and SRLG safe (link |
| protection)"; | | protection)"; |
| } | | } |
| } | | } |
| description | | description |
| "FRR backup status"; | | "FRR backup status"; |
| } | | } |
| | | |
| typedef Te-sync-pending-reason { | | typedef Te-sync-pending-reason { |
| type enumeration { | | type enumeration { |
| enum "current-lspoos" { | | enum "current-lspoos" { |
| description | | description |
| "Current LSP OOS"; | | "Current LSP OOS"; |
| } | | } |
| enum "reopt-lspoos" { | | enum "reopt-lspoos" { |
| description | | description |
| "Reopt LSP OOS"; | | "Reopt LSP OOS"; |
| } | | } |
| enum "standby-lspoos" { | | enum "standby-lspoos" { |
| description | | description |
| "Standby LSP OOS"; | | "Standby LSP OOS"; |
| } | | } |
| enum "standby-reopt-lspoos" { | | enum "standby-reopt-lspoos" { |
| description | | description |
| "Standby Reopt LSP OOS"; | | "Standby Reopt LSP OOS"; |
| } | | } |
| enum "restore-lspoos" { | | enum "restore-lspoos" { |
| description | | description |
| "Restore LSP OOS"; | | "Restore LSP OOS"; |
| } | | } |
| enum "invalid-sync-id" { | | enum "invalid-sync-id" { |
| description | | description |
| "Invalid internal ID"; | | "Invalid internal ID"; |
| } | | } |
| enum "null-pointer" { | | enum "null-pointer" { |
| description | | description |
| "Null pointer"; | | "Null pointer"; |
| } | | } |
| enum "pending-flag" { | | enum "pending-flag" { |
| description | | description |
| "Pending flag set"; | | "Pending flag set"; |
| } | | } |
| enum "del-from-act-flag" { | | enum "del-from-act-flag" { |
| description | | description |
| "Deleted by Active set"; | | "Deleted by Active set"; |
| } | | } |
| enum "oos-from-act-flag" { | | enum "oos-from-act-flag" { |
| description | | description |
| "OOS with Active set"; | | "OOS with Active set"; |
| } | | } |
| enum "unknown" { | | enum "unknown" { |
| description | | description |
| "Unknown"; | | "Unknown"; |
| } | | } |
| } | | } |
| description | | description |
| "Te sync pending reason"; | | "Te sync pending reason"; |
| } | | } |
| | | |
| typedef Te-sync-not-ready-reason { | | typedef Te-sync-not-ready-reason { |
| type enumeration { | | type enumeration { |
| enum "idt-in-progress" { | | enum "idt-in-progress" { |
| description | | description |
| "IDT in progress"; | | "IDT in progress"; |
| } | | } |
| enum "standby-not-connected" { | | enum "standby-not-connected" { |
| description | | description |
| "Standby not connected"; | | "Standby not connected"; |
| } | | } |
| enum "collaborator-disconnected" { | | enum "collaborator-disconnected" { |
| description | | description |
| "Collaborator disconnected"; | | "Collaborator disconnected"; |
| } | | } |
| enum "collaborator-timeout" { | | enum "collaborator-timeout" { |
| description | | description |
| "Collaborator timeout"; | | "Collaborator timeout"; |
| } | | } |
| enum "unknown" { | | enum "unknown" { |
| description | | description |
| "Unknown"; | | "Unknown"; |
| } | | } |
| } | | } |
| description | | description |
| "Te sync not ready reason"; | | "Te sync not ready reason"; |
| } | | } |
| | | |
| typedef Te-sync-status-show { | | typedef Te-sync-status-show { |
| type enumeration { | | type enumeration { |
| enum "master-sync-status-show" { | | enum "master-sync-status-show" { |
| description | | description |
| "Master sync status information"; | | "Master sync status information"; |
| } | | } |
| enum "slave-sync-status-show" { | | enum "slave-sync-status-show" { |
| description | | description |
| "Slave sync status information"; | | "Slave sync status information"; |
| } | | } |
| } | | } |
| description | | description |
| "Te sync status show"; | | "Te sync status show"; |
| } | | } |
| | | |
| typedef Mpls-te-dste-class-status { | | typedef Mpls-te-dste-class-status { |
| type enumeration { | | type enumeration { |
| enum "configured" { | | enum "configured" { |
| description | | description |
| "The TE class is explicitely configured"; | | "The TE class is explicitely configured"; |
| } | | } |
| enum "default" { | | enum "default" { |
| description | | description |
| "The TE class is a default"; | | "The TE class is a default"; |
| } | | } |
| enum "unused" { | | enum "unused" { |
| description | | description |
| "The TE class is unused due to a configuration | | "The TE class is unused due to a configuration |
| conflict"; | | conflict"; |
| } | | } |
| } | | } |
| description | | description |
| "DSTE class status"; | | "DSTE class status"; |
| } | | } |
| | | |
| typedef Te-proc-role { | | typedef Te-proc-role { |
| type enumeration { | | type enumeration { |
| enum "unknown" { | | enum "unknown" { |
| description | | description |
| "Unknown"; | | "Unknown"; |
| } | | } |
| enum "v1-active" { | | enum "v1-active" { |
| description | | description |
| "V1 Active"; | | "V1 Active"; |
| } | | } |
| enum "v2-active" { | | enum "v2-active" { |
| description | | description |
| "V2 Active"; | | "V2 Active"; |
| } | | } |
| enum "v1-standby" { | | enum "v1-standby" { |
| description | | description |
| "V1 Standby"; | | "V1 Standby"; |
| } | | } |
| enum "v2-standby" { | | enum "v2-standby" { |
| description | | description |
| "V2 Standby"; | | "V2 Standby"; |
| } | | } |
| enum "v1-active-post-big-bang" { | | enum "v1-active-post-big-bang" { |
| description | | description |
| "V1 Active post big bang"; | | "V1 Active post big bang"; |
| } | | } |
| enum "v1-standby-post-big-bang" { | | enum "v1-standby-post-big-bang" { |
| description | | description |
| "V1 Standby post big bang"; | | "V1 Standby post big bang"; |
| } | | } |
| enum "number-of-role" { | | enum "number-of-role" { |
| description | | description |
| "Number of role"; | | "Number of role"; |
| } | | } |
| } | | } |
| description | | description |
| "TE Process Role"; | | "TE Process Role"; |
| } | | } |
| | | |
| typedef Te-acl { | | typedef Te-acl { |
| type enumeration { | | type enumeration { |
| enum "acl-type-unknown" { | | enum "acl-type-unknown" { |
| value 0; | | value 0; |
| description | | description |
| "Unknown type of ACL"; | | "Unknown type of ACL"; |
| } | | } |
| enum "acl-type-access-list" { | | enum "acl-type-access-list" { |
| value 1; | | value 1; |
| description | | description |
| "Access-list type of ACL"; | | "Access-list type of ACL"; |
| } | | } |
| enum "acl-type-prefix-list" { | | enum "acl-type-prefix-list" { |
| value 2; | | value 2; |
| description | | description |
| "Prefix-list type of ACL"; | | "Prefix-list type of ACL"; |
| } | | } |
| enum "acl-type-unregistered" { | | enum "acl-type-unregistered" { |
| value 3; | | value 3; |
| description | | description |
| "ACL failed to register to ACL infra"; | | "ACL failed to register to ACL infra"; |
| } | | } |
| } | | } |
| description | | description |
| "Te acl"; | | "Te acl"; |
| } | | } |
| | | |
| typedef Mpls-te-p2mp-timer { | | typedef Mpls-te-p2mp-timer { |
| type enumeration { | | type enumeration { |
| enum "lmrib-restart" { | | enum "lmrib-restart" { |
| value 0; | | value 0; |
| description | | description |
| "P2MP Local Multicast RIB restart"; | | "P2MP Local Multicast RIB restart"; |
| } | | } |
| enum "lmrib-recovery" { | | enum "lmrib-recovery" { |
| value 1; | | value 1; |
| description | | description |
| "P2MP LMRIB recovery"; | | "P2MP LMRIB recovery"; |
| } | | } |
| enum "rsvp-restart" { | | enum "rsvp-restart" { |
| value 2; | | value 2; |
| description | | description |
| "P2MP RSVP restart"; | | "P2MP RSVP restart"; |
| } | | } |
| enum "lsd-restart" { | | enum "lsd-restart" { |
| value 3; | | value 3; |
| description | | description |
| "LSD restart"; | | "LSD restart"; |
| } | | } |
| enum "lsd-recovery" { | | enum "lsd-recovery" { |
| value 4; | | value 4; |
| description | | description |
| "LSD recovery"; | | "LSD recovery"; |
| } | | } |
| enum "clear-in-progress-bandwidth" { | | enum "clear-in-progress-bandwidth" { |
| value 5; | | value 5; |
| description | | description |
| "Timer to clear the inprogress bandwidth for all | | "Timer to clear the inprogress bandwidth for all |
| the nodes in the topology"; | | the nodes in the topology"; |
| } | | } |
| enum "rsi-restart" { | | enum "rsi-restart" { |
| value 6; | | value 6; |
| description | | description |
| "RSI restart"; | | "RSI restart"; |
| } | | } |
| enum "rsi-recovery" { | | enum "rsi-recovery" { |
| value 7; | | value 7; |
| description | | description |
| "RSI recovery"; | | "RSI recovery"; |
| } | | } |
| enum "ipv4-caps-replay" { | | enum "ipv4-caps-replay" { |
| value 8; | | value 8; |
| description | | description |
| "Timer to timeout the replay of IPv4 Caps after | | "Timer to timeout the replay of IPv4 Caps after |
| a TE or IM restart"; | | a TE or IM restart"; |
| } | | } |
| enum "retry-acl-registration-timer" { | | enum "retry-acl-registration-timer" { |
| value 9; | | value 9; |
| description | | description |
| "Timer to retry ACL registration"; | | "Timer to retry ACL registration"; |
| } | | } |
| enum "mpls-te-exit" { | | enum "mpls-te-exit" { |
| value 10; | | value 10; |
| description | | description |
| "MPLS TE Exit"; | | "MPLS TE Exit"; |
| } | | } |
| enum "mpls-te-nsr-peer-restart" { | | enum "mpls-te-nsr-peer-restart" { |
| value 11; | | value 11; |
| description | | description |
| "MPLS TE NSR Peer Restart"; | | "MPLS TE NSR Peer Restart"; |
| } | | } |
| enum "mpls-te-issu-peer-restart" { | | enum "mpls-te-issu-peer-restart" { |
| value 12; | | value 12; |
| description | | description |
| "MPLS TE ISSU Peer Restart"; | | "MPLS TE ISSU Peer Restart"; |
| } | | } |
| enum "bfd-restart" { | | enum "bfd-restart" { |
| value 13; | | value 13; |
| description | | description |
| "BFD restart"; | | "BFD restart"; |
| } | | } |
| enum "bfd-recovery" { | | enum "bfd-recovery" { |
| value 14; | | value 14; |
| description | | description |
| "BFD recovery"; | | "BFD recovery"; |
| } | | } |
| enum "im-oc-restart" { | | enum "im-oc-restart" { |
| value 15; | | value 15; |
| description | | description |
| "IM Optical Connection restart"; | | "IM Optical Connection restart"; |
| } | | } |
| enum "im-oc-recovery" { | | enum "im-oc-recovery" { |
| value 16; | | value 16; |
| description | | description |
| "IM Optical Connection recovery"; | | "IM Optical Connection recovery"; |
| } | | } |
| enum "rib-restart" { | | enum "rib-restart" { |
| value 17; | | value 17; |
| description | | description |
| "RIB restart"; | | "RIB restart"; |
| } | | } |
| enum "rib-recovery" { | | enum "rib-recovery" { |
| value 18; | | value 18; |
| description | | description |
| "RIB recovery"; | | "RIB recovery"; |
| } | | } |
| enum "rib-next-hop-route-cleanup" { | | enum "rib-next-hop-route-cleanup" { |
| value 19; | | value 19; |
| description | | description |
| "RIB next-hop route cleanup"; | | "RIB next-hop route cleanup"; |
| } | | } |
| enum "rsi-srlg-producer-retry" { | | enum "rsi-srlg-producer-retry" { |
| value 20; | | value 20; |
| description | | description |
| "RSI SRLG-producer connection retry"; | | "RSI SRLG-producer connection retry"; |
| } | | } |
| enum "eoc-reg-retry" { | | enum "eoc-reg-retry" { |
| value 21; | | value 21; |
| description | | description |
| "End-of-Config registration retry"; | | "End-of-Config registration retry"; |
| } | | } |
| enum "fib-restart" { | | enum "fib-restart" { |
| value 22; | | value 22; |
| description | | description |
| "FIB restart"; | | "FIB restart"; |
| } | | } |
| enum "fib-recovery" { | | enum "fib-recovery" { |
| value 23; | | value 23; |
| description | | description |
| "FIB recovery"; | | "FIB recovery"; |
| } | | } |
| enum "fib-next-hop-route-cleanup" { | | enum "fib-next-hop-route-cleanup" { |
| value 24; | | value 24; |
| description | | description |
| "FIB next-hop route cleanup"; | | "FIB next-hop route cleanup"; |
| } | | } |
| enum "fib-next-hop-register-retry" { | | enum "fib-next-hop-register-retry" { |
| value 25; | | value 25; |
| description | | description |
| "FIB next-hop register retry"; | | "FIB next-hop register retry"; |
| } | | } |
| enum "tun-backend-scan-retry" { | | enum "tun-backend-scan-retry" { |
| value 26; | | value 26; |
| description | | description |
| "Tunnel Backend Scan Retry"; | | "Tunnel Backend Scan Retry"; |
| } | | } |
| enum "tunnel-checkpoint-list-service" { | | enum "tunnel-checkpoint-list-service" { |
| value 27; | | value 27; |
| description | | description |
| "Tunnel Checkpoint list service"; | | "Tunnel Checkpoint list service"; |
| } | | } |
| enum "tunnel-service-binding-sid-allocation-retry" { | | enum "tunnel-service-binding-sid-allocation-retry" { |
| value 28; | | value 28; |
| description | | description |
| "Tunnel Service Binding SID Allocation Retry"; | | "Tunnel Service Binding SID Allocation Retry"; |
| } | | } |
| enum "im-sync-delay" { | | enum "im-sync-delay" { |
| value 29; | | value 29; |
| description | | description |
| "IM sync delay"; | | "IM sync delay"; |
| } | | } |
| enum "timer-not-used" { | | enum "timer-not-used" { |
| value 30; | | value 30; |
| description | | description |
| "Do not use"; | | "Do not use"; |
| } | | } |
| } | | } |
| description | | description |
| "P2MP timer types"; | | "P2MP timer types"; |
| } | | } |
| | | |
| typedef Mpls-te-afi { | | typedef Mpls-te-afi { |
| type enumeration { | | type enumeration { |
| enum "ipv4-unicast" { | | enum "ipv4-unicast" { |
| description | | description |
| "MPLS TE IPv4 unicast"; | | "MPLS TE IPv4 unicast"; |
| } | | } |
| enum "ipv4-multicast" { | | enum "ipv4-multicast" { |
| description | | description |
| "MPLS TE IPv4 multicast"; | | "MPLS TE IPv4 multicast"; |
| } | | } |
| enum "ipv6-unicast" { | | enum "ipv6-unicast" { |
| description | | description |
| "MPLS TE IPv6 unicast"; | | "MPLS TE IPv6 unicast"; |
| } | | } |
| enum "ipv6-multicast" { | | enum "ipv6-multicast" { |
| description | | description |
| "MPLS TE IPv6 multicast"; | | "MPLS TE IPv6 multicast"; |
| } | | } |
| } | | } |
| description | | description |
| "Mpls te afi"; | | "Mpls te afi"; |
| } | | } |
| | | |
| typedef Mpls-te-tunnel-announce { | | typedef Mpls-te-tunnel-announce { |
| type enumeration { | | type enumeration { |
| enum "announce-type-not-set" { | | enum "announce-type-not-set" { |
| description | | description |
| "Tunnel announcement type not set"; | | "Tunnel announcement type not set"; |
| } | | } |
| enum "autoroute" { | | enum "autoroute" { |
| description | | description |
| "Autoroute-announced tunnel"; | | "Autoroute-announced tunnel"; |
| } | | } |
| enum "forward-adjacency" { | | enum "forward-adjacency" { |
| description | | description |
| "Forwarding-adjacency tunnel"; | | "Forwarding-adjacency tunnel"; |
| } | | } |
| } | | } |
| description | | description |
| "Type of TE tunnel announcement to IGP"; | | "Type of TE tunnel announcement to IGP"; |
| } | | } |
| | | |
| typedef Te-target-addr { | | typedef Te-target-addr { |
| type enumeration { | | type enumeration { |
| enum "invalid-te-target-type" { | | enum "invalid-te-target-type" { |
| description | | description |
| "Invalid TE Target Type"; | | "Invalid TE Target Type"; |
| } | | } |
| enum "te-target-type-ipv4" { | | enum "te-target-type-ipv4" { |
| description | | description |
| "TE Target IPv4 Type"; | | "TE Target IPv4 Type"; |
| } | | } |
| enum "te-target-type-label" { | | enum "te-target-type-label" { |
| description | | description |
| "TE Target Label Type"; | | "TE Target Label Type"; |
| } | | } |
| } | | } |
| description | | description |
| "TE Target Address Type"; | | "TE Target Address Type"; |
| } | | } |
| | | |
| typedef Flex-lsp-lockout-origination { | | typedef Flex-lsp-lockout-origination { |
| type enumeration { | | type enumeration { |
| enum "lockout-origination-none" { | | enum "lockout-origination-none" { |
| description | | description |
| "Flex LSP Lockout Origination None"; | | "Flex LSP Lockout Origination None"; |
| } | | } |
| enum "lockout-origination-local" { | | enum "lockout-origination-local" { |
| description | | description |
| "Flex LSP Lockout Originated From Local"; | | "Flex LSP Lockout Originated From Local"; |
| } | | } |
| enum "lockout-origination-remote" { | | enum "lockout-origination-remote" { |
| description | | description |
| "Flex LSP Lockout Originated From Remote"; | | "Flex LSP Lockout Originated From Remote"; |
| } | | } |
| } | | } |
| description | | description |
| "TE Flex LSP Lockout Origination"; | | "TE Flex LSP Lockout Origination"; |
| } | | } |
| | | |
| typedef Te-rev-ero-reject-reasons { | | typedef Te-rev-ero-reject-reasons { |
| type enumeration { | | type enumeration { |
| enum "none" { | | enum "none" { |
| description | | description |
| "None"; | | "None"; |
| } | | } |
| enum "bad-reverse-ero" { | | enum "bad-reverse-ero" { |
| description | | description |
| "Bad Reverse ERO"; | | "Bad Reverse ERO"; |
| } | | } |
| enum "tie-rejected" { | | enum "tie-rejected" { |
| description | | description |
| "Tie Rejected"; | | "Tie Rejected"; |
| } | | } |
| enum "standby-not-required" { | | enum "standby-not-required" { |
| description | | description |
| "Standby Not Required"; | | "Standby Not Required"; |
| } | | } |
| enum "admin-state" { | | enum "admin-state" { |
| description | | description |
| "Admin State"; | | "Admin State"; |
| } | | } |
| enum "priority" { | | enum "priority" { |
| description | | description |
| "Priority"; | | "Priority"; |
| } | | } |
| enum "class-type" { | | enum "class-type" { |
| description | | description |
| "Class Type"; | | "Class Type"; |
| } | | } |
| enum "bad-association" { | | enum "bad-association" { |
| description | | description |
| "Bad Associated Tunnel"; | | "Bad Associated Tunnel"; |
| } | | } |
| } | | } |
| description | | description |
| "TE Reverse ERO Reject Reasons"; | | "TE Reverse ERO Reject Reasons"; |
| } | | } |
| | | |
| typedef Mte-path-option { | | typedef Mte-path-option { |
| type enumeration { | | type enumeration { |
| enum "none" { | | enum "none" { |
| description | | description |
| "No Path Option type"; | | "No Path Option type"; |
| } | | } |
| enum "dynamic" { | | enum "dynamic" { |
| description | | description |
| "Dynamic Path Option type"; | | "Dynamic Path Option type"; |
| } | | } |
| enum "explicit" { | | enum "explicit" { |
| description | | description |
| "Explicit Path Option type"; | | "Explicit Path Option type"; |
| } | | } |
| enum "no-ero" { | | enum "no-ero" { |
| description | | description |
| "No ERO Path Option type"; | | "No ERO Path Option type"; |
| } | | } |
| enum "segment-routing" { | | enum "segment-routing" { |
| description | | description |
| "One SID SegmentRouting Path Option type"; | | "One SID SegmentRouting Path Option type"; |
| } | | } |
| enum "po-count" { | | enum "po-count" { |
| description | | description |
| "Number of Path option types"; | | "Number of Path option types"; |
| } | | } |
| } | | } |
| description | | description |
| "Path Option Type"; | | "Path Option Type"; |
| } | | } |
| | | |
| typedef Mpls-te-mgmt-gmpls-label-origin { | | typedef Mpls-te-mgmt-gmpls-label-origin { |
| type enumeration { | | type enumeration { |
| enum "not-set" { | | enum "not-set" { |
| description | | description |
| "Not set"; | | "Not set"; |
| } | | } |
| enum "uni-c" { | | enum "uni-c" { |
| description | | description |
| "UNI C"; | | "UNI C"; |
| } | | } |
| enum "uni-n" { | | enum "uni-n" { |
| description | | description |
| "UNI N"; | | "UNI N"; |
| } | | } |
| } | | } |
| description | | description |
| "GMPLS label source"; | | "GMPLS label source"; |
| } | | } |
| | | |
| typedef Mpls-te-tunnel-state { | | typedef Mpls-te-tunnel-state { |
| type enumeration { | | type enumeration { |
| enum "state-down" { | | enum "state-down" { |
| description | | description |
| "Tunnel state is down"; | | "Tunnel state is down"; |
| } | | } |
| enum "state-up" { | | enum "state-up" { |
| description | | description |
| "Tunnel state is up"; | | "Tunnel state is up"; |
| } | | } |
| enum "state-down-policy" { | | enum "state-down-policy" { |
| description | | description |
| "Tunnel state is down as it has been deactivated | | "Tunnel state is down as it has been deactivated |
| administratively"; | | administratively"; |
| } | | } |
| enum "state-lockout" { | | enum "state-lockout" { |
| description | | description |
| "Tunnel state is lockout"; | | "Tunnel state is lockout"; |
| } | | } |
| } | | } |
| description | | description |
| "Tunnel state"; | | "Tunnel state"; |
| } | | } |
| | | |
| typedef Mpls-te-soft-preemption-resolution { | | typedef Mpls-te-soft-preemption-resolution { |
| type enumeration { | | type enumeration { |
| enum "soft-preemption-resolution-none" { | | enum "soft-preemption-resolution-none" { |
| value 0; | | value 0; |
| description | | description |
| "No Soft Preemption Resolution"; | | "No Soft Preemption Resolution"; |
| } | | } |
| enum "soft-preemption-resolution-pending" { | | enum "soft-preemption-resolution-pending" { |
| value 1; | | value 1; |
| description | | description |
| "Soft Preemption has no resolution since it is | | "Soft Preemption has no resolution since it is |
| still pending"; | | still pending"; |
| } | | } |
| enum "soft-preemption-resolution-reopt-completed" { | | enum "soft-preemption-resolution-reopt-completed" { |
| value 2; | | value 2; |
| description | | description |
| "The soft preempted LSP has been reoptimized"; | | "The soft preempted LSP has been reoptimized"; |
| } | | } |
| enum "soft-preemption-resolution-teardown" { | | enum "soft-preemption-resolution-teardown" { |
| value 3; | | value 3; |
| description | | description |
| "The soft preempted LSP has been torn"; | | "The soft preempted LSP has been torn"; |
| } | | } |
| enum "soft-preemption-resolution-frr-triggered" { | | enum "soft-preemption-resolution-frr-triggered" { |
| value 4; | | value 4; |
| description | | description |
| "The soft preempted LSP has been fast rerouted"; | | "The soft preempted LSP has been fast rerouted"; |
| } | | } |
| enum "soft-preemption-resolution-path-protetion-switchover" { | | enum "soft-preemption-resolution-path-protetion-switchover" { |
| value 5; | | value 5; |
| description | | description |
| "The soft preempted LSP was switched with the | | "The soft preempted LSP was switched with the |
| protection LSP"; | | protection LSP"; |
| } | | } |
| } | | } |
| description | | description |
| "The possible ways for soft preemption to end"; | | "The possible ways for soft preemption to end"; |
| } | | } |
| | | |
| typedef Mpls-te-iep-hop { | | typedef Mpls-te-iep-hop { |
| type enumeration { | | type enumeration { |
| enum "iep-hop-type-unknown" { | | enum "iep-hop-type-unknown" { |
| description | | description |
| "Unknown IEP hop type"; | | "Unknown IEP hop type"; |
| } | | } |
| enum "iep-hop-type-strict-next" { | | enum "iep-hop-type-strict-next" { |
| description | | description |
| "Strict next IEP hop type"; | | "Strict next IEP hop type"; |
| } | | } |
| enum "iep-hop-type-exclude" { | | enum "iep-hop-type-exclude" { |
| description | | description |
| "Exclude IEP hop type"; | | "Exclude IEP hop type"; |
| } | | } |
| enum "iep-hop-type-exclude-node" { | | enum "iep-hop-type-exclude-node" { |
| description | | description |
| "Exclude Node IEP hop type"; | | "Exclude Node IEP hop type"; |
| } | | } |
| enum "iep-hop-type-exclude-srlg" { | | enum "iep-hop-type-exclude-srlg" { |
| description | | description |
| "Exclude SRLG IEP hop type"; | | "Exclude SRLG IEP hop type"; |
| } | | } |
| enum "iep-hop-type-loose-next" { | | enum "iep-hop-type-loose-next" { |
| description | | description |
| "Loose next IEP hop type"; | | "Loose next IEP hop type"; |
| } | | } |
| enum "iep-hop-type-next" { | | enum "iep-hop-type-next" { |
| description | | description |
| "Next IEP hop type"; | | "Next IEP hop type"; |
| } | | } |
| enum "iep-hop-type-share-srlg" { | | enum "iep-hop-type-share-srlg" { |
| description | | description |
| "Weighted SRLG IEP hop type"; | | "Weighted SRLG IEP hop type"; |
| } | | } |
| } | | } |
| description | | description |
| "Explicit path hop type"; | | "Explicit path hop type"; |
| } | | } |
| | | |
| typedef Mpls-te-pce-fail-reasons { | | typedef Mpls-te-pce-fail-reasons { |
| type enumeration { | | type enumeration { |
| enum "te-pce-fail-no-reason" { | | enum "te-pce-fail-no-reason" { |
| description | | description |
| "No reason"; | | "No reason"; |
| } | | } |
| enum "te-pce-fail-no-pce" { | | enum "te-pce-fail-no-pce" { |
| description | | description |
| "No PCE to send request"; | | "No PCE to send request"; |
| } | | } |
| enum "te-pce-fail-sub-pool" { | | enum "te-pce-fail-sub-pool" { |
| description | | description |
| "Sub pool bandwidth tunnel"; | | "Sub pool bandwidth tunnel"; |
| } | | } |
| enum "te-pce-fail-intra-area" { | | enum "te-pce-fail-intra-area" { |
| description | | description |
| "Intra Area Tunnel"; | | "Intra Area Tunnel"; |
| } | | } |
| enum "te-pce-fail-gmpls" { | | enum "te-pce-fail-gmpls" { |
| description | | description |
| "GMPLS Tunnel"; | | "GMPLS Tunnel"; |
| } | | } |
| enum "te-pce-fail-pending" { | | enum "te-pce-fail-pending" { |
| description | | description |
| "Pending request"; | | "Pending request"; |
| } | | } |
| enum "te-pce-fail-oor" { | | enum "te-pce-fail-oor" { |
| description | | description |
| "OOR condition"; | | "OOR condition"; |
| } | | } |
| enum "te-pce-fail-bidirectional" { | | enum "te-pce-fail-bidirectional" { |
| description | | description |
| "Bi directional"; | | "Bi directional"; |
| } | | } |
| enum "te-pce-fail-no-path" { | | enum "te-pce-fail-no-path" { |
| description | | description |
| "No Path received from PCE"; | | "No Path received from PCE"; |
| } | | } |
| enum "te-pce-fail-request-timeout" { | | enum "te-pce-fail-request-timeout" { |
| description | | description |
| "Request Timeout"; | | "Request Timeout"; |
| } | | } |
| } | | } |
| description | | description |
| "PCE failure reasons"; | | "PCE failure reasons"; |
| n | } | n | |
| | | |
| typedef Self-ping-state { | | |
| type enumeration { | | |
| enum "self-ping-none" { | | |
| value 0; | | |
| description | | |
| "There is no self-ping operation"; | | |
| } | | |
| enum "self-ping-underway" { | | |
| value 1; | | |
| description | | |
| "Self ping operation is underway"; | | |
| } | | |
| enum "self-ping-timed-out" { | | |
| value 2; | | |
| description | | |
| "Self ping operation timed out"; | | |
| } | | |
| enum "self-ping-terminated" { | | |
| value 3; | | |
| description | | |
| "Self ping operation was terminated"; | | |
| } | | |
| enum "self-ping-succeeded" { | | |
| value 4; | | |
| description | | |
| "Self ping operation succeeded"; | | |
| } | | |
| } | | |
| description | | |
| "Self ping operation state"; | | |
| } | | } |
| | | |
| typedef Te-autobw-app-rej { | | typedef Te-autobw-app-rej { |
| type enumeration { | | type enumeration { |
| enum "application-allowed" { | | enum "application-allowed" { |
| description | | description |
| "Application allowed"; | | "Application allowed"; |
| } | | } |
| enum "auto-bw-disabled" { | | enum "auto-bw-disabled" { |
| description | | description |
| "Auto-bw disabled"; | | "Auto-bw disabled"; |
| } | | } |
| enum "tunnel-is-down" { | | enum "tunnel-is-down" { |
| description | | description |
| "TunnelIsDown"; | | "TunnelIsDown"; |
| } | | } |
| enum "tunnel-is-frr" { | | enum "tunnel-is-frr" { |
| description | | description |
| "TunnelIsFRRActive"; | | "TunnelIsFRRActive"; |
| } | | } |
| enum "tunnel-is-backup" { | | enum "tunnel-is-backup" { |
| description | | description |
| "TunnelIsBackup"; | | "TunnelIsBackup"; |
| } | | } |
| enum "tunnel-is-lock-down" { | | enum "tunnel-is-lock-down" { |
| description | | description |
| "TunnelIsLockdown"; | | "TunnelIsLockdown"; |
| } | | } |
| } | | } |
| description | | description |
| "Reason for auto-bandwidth application rejection"; | | "Reason for auto-bandwidth application rejection"; |
| } | | } |
| | | |
| typedef Te-autobw-app-trigger { | | typedef Te-autobw-app-trigger { |
| type enumeration { | | type enumeration { |
| enum "application-none" { | | enum "application-none" { |
| description | | description |
| "No BW Application"; | | "No BW Application"; |
| } | | } |
| enum "application-periodic" { | | enum "application-periodic" { |
| description | | description |
| "BW Application Periodic"; | | "BW Application Periodic"; |
| } | | } |
| enum "application-manual" { | | enum "application-manual" { |
| description | | description |
| "BW Application Manual"; | | "BW Application Manual"; |
| } | | } |
| enum "application-overflow" { | | enum "application-overflow" { |
| description | | description |
| "BW Application Overflow"; | | "BW Application Overflow"; |
| } | | } |
| enum "application-underflow" { | | enum "application-underflow" { |
| description | | description |
| "BW Application Underflow"; | | "BW Application Underflow"; |
| } | | } |
| } | | } |
| description | | description |
| "Auto-bandwidth application trigger"; | | "Auto-bandwidth application trigger"; |
| } | | } |
| | | |
| typedef Te-hop-limit-ignore { | | typedef Te-hop-limit-ignore { |
| type enumeration { | | type enumeration { |
| enum "ignore-unknown" { | | enum "ignore-unknown" { |
| description | | description |
| "Ignore for an unknown reason"; | | "Ignore for an unknown reason"; |
| } | | } |
| enum "ignore-explicit" { | | enum "ignore-explicit" { |
| description | | description |
| "Ignore due to explicit path option"; | | "Ignore due to explicit path option"; |
| } | | } |
| enum "ignore-pce" { | | enum "ignore-pce" { |
| description | | description |
| "Ignore due to PCE path option"; | | "Ignore due to PCE path option"; |
| } | | } |
| } | | } |
| description | | description |
| "Te hop limit ignore"; | | "Te hop limit ignore"; |
| } | | } |
| | | |
| typedef Mpls-te-metric-qualifier { | | typedef Mpls-te-metric-qualifier { |
| type enumeration { | | type enumeration { |
| enum "metric-default" { | | enum "metric-default" { |
| description | | description |
| "Default metric"; | | "Default metric"; |
| } | | } |
| enum "metric-global" { | | enum "metric-global" { |
| description | | description |
| "This metric was specified globally"; | | "This metric was specified globally"; |
| } | | } |
| enum "metric-interface" { | | enum "metric-interface" { |
| description | | description |
| "This metric was specified on this particular | | "This metric was specified on this particular |
| tunnel"; | | tunnel"; |
| } | | } |
| } | | } |
| description | | description |
| "Metric qualifier"; | | "Metric qualifier"; |
| } | | } |
| | | |
| typedef Te-path-selection-tiebreaker { | | typedef Te-path-selection-tiebreaker { |
| type enumeration { | | type enumeration { |
| enum "min-fill" { | | enum "min-fill" { |
| value 1; | | value 1; |
| description | | description |
| "Min Fill"; | | "Min Fill"; |
| } | | } |
| enum "max-fill" { | | enum "max-fill" { |
| value 2; | | value 2; |
| description | | description |
| "Max Fill"; | | "Max Fill"; |
| } | | } |
| enum "random" { | | enum "random" { |
| value 3; | | value 3; |
| description | | description |
| "Random"; | | "Random"; |
| } | | } |
| } | | } |
| description | | description |
| "Path selection tiebreaker type"; | | "Path selection tiebreaker type"; |
| } | | } |
| | | |
| typedef Mpls-te-loadshare { | | typedef Mpls-te-loadshare { |
| type enumeration { | | type enumeration { |
| enum "loadshare-equal" { | | enum "loadshare-equal" { |
| description | | description |
| "Equal load-sharing on this tunnel"; | | "Equal load-sharing on this tunnel"; |
| } | | } |
| enum "loadshare-bandwidth-based" { | | enum "loadshare-bandwidth-based" { |
| description | | description |
| "Loadshare inferred from bandwidth configuration"; | | "Loadshare inferred from bandwidth configuration"; |
| } | | } |
| enum "loadshare-configured" { | | enum "loadshare-configured" { |
| description | | description |
| "Loadshare determined from explicit | | "Loadshare determined from explicit |
| configuration"; | | configuration"; |
| } | | } |
| } | | } |
| description | | description |
| "load-share type"; | | "load-share type"; |
| } | | } |
| | | |
| typedef Te-destination-state { | | typedef Te-destination-state { |
| type enumeration { | | type enumeration { |
| enum "destination-disabled" { | | enum "destination-disabled" { |
| description | | description |
| "The destination is disabled in configuration"; | | "The destination is disabled in configuration"; |
| } | | } |
| enum "destination-down" { | | enum "destination-down" { |
| description | | description |
| "The destination is down"; | | "The destination is down"; |
| } | | } |
| enum "destination-up" { | | enum "destination-up" { |
| description | | description |
| "The destination is up"; | | "The destination is up"; |
| } | | } |
| } | | } |
| description | | description |
| "P2MP destination state"; | | "P2MP destination state"; |
| } | | } |
| | | |
| typedef Mpls-mte-tunnel-fail-reason { | | typedef Mpls-mte-tunnel-fail-reason { |
| type enumeration { | | type enumeration { |
| enum "mtunnel-fail-reason-unapplicable" { | | enum "mtunnel-fail-reason-unapplicable" { |
| description | | description |
| "None of the reasons below is valid"; | | "None of the reasons below is valid"; |
| } | | } |
| enum "mtunnel-fail-reason-shutdown" { | | enum "mtunnel-fail-reason-shutdown" { |
| description | | description |
| "Tunnel interface is shutdown"; | | "Tunnel interface is shutdown"; |
| } | | } |
| enum "mtunnel-fail-reason-no-destination" { | | enum "mtunnel-fail-reason-no-destination" { |
| description | | description |
| "No destination is configured"; | | "No destination is configured"; |
| } | | } |
| enum "mtunnel-fail-reason-no-path-option" { | | enum "mtunnel-fail-reason-no-path-option" { |
| description | | description |
| "No path option is configured"; | | "No path option is configured"; |
| } | | } |
| enum "mtunnel-fail-reason-no-source" { | | enum "mtunnel-fail-reason-no-source" { |
| description | | description |
| "No ip source address is configured"; | | "No ip source address is configured"; |
| } | | } |
| enum "mtunnel-fail-reason-collaborator-disc" { | | enum "mtunnel-fail-reason-collaborator-disc" { |
| description | | description |
| "Collaborator not connected"; | | "Collaborator not connected"; |
| } | | } |
| enum "mtunnel-fail-reason-unmatched-class-type-priority" { | | enum "mtunnel-fail-reason-unmatched-class-type-priority" { |
| description | | description |
| "The class type and priority do not match any of | | "The class type and priority do not match any of |
| the TE-classes"; | | the TE-classes"; |
| } | | } |
| enum "mtunnel-fail-reason-invalid-bidir-cfg" { | | enum "mtunnel-fail-reason-invalid-bidir-cfg" { |
| description | | description |
| "Configured bidirectional, incomplete switching | | "Configured bidirectional, incomplete switching |
| capability config"; | | capability config"; |
| } | | } |
| enum "mtunnel-fail-reason-po-switchover" { | | enum "mtunnel-fail-reason-po-switchover" { |
| description | | description |
| "Manual path-option switchover failed due to | | "Manual path-option switchover failed due to |
| destination(s) down"; | | destination(s) down"; |
| } | | } |
| enum "mtunnel-fail-reason-no-tunnel-id" { | | enum "mtunnel-fail-reason-no-tunnel-id" { |
| description | | description |
| "No tunnel-id is configured"; | | "No tunnel-id is configured"; |
| } | | } |
| enum "mtunnel-fail-reason-no-link" { | | enum "mtunnel-fail-reason-no-link" { |
| description | | description |
| "Tunnel's egress link doesn't exist"; | | "Tunnel's egress link doesn't exist"; |
| } | | } |
| enum "mtunnel-fail-reason-link-shutdown" { | | enum "mtunnel-fail-reason-link-shutdown" { |
| description | | description |
| "Tunnel's egress link is shut down"; | | "Tunnel's egress link is shut down"; |
| } | | } |
| enum "mtunnel-fail-reason-link-lmp-down" { | | enum "mtunnel-fail-reason-link-lmp-down" { |
| description | | description |
| "LMP is down on the tunnel's egress link"; | | "LMP is down on the tunnel's egress link"; |
| } | | } |
| enum "mtunnel-fail-reason-source-destination-same" { | | enum "mtunnel-fail-reason-source-destination-same" { |
| description | | description |
| "Tunnel source and destination addresses are the | | "Tunnel source and destination addresses are the |
| same"; | | same"; |
| } | | } |
| enum "mtunnel-fail-reason-otn-no-odu-level" { | | enum "mtunnel-fail-reason-otn-no-odu-level" { |
| description | | description |
| "OTN tunnel does not have odu-level set"; | | "OTN tunnel does not have odu-level set"; |
| } | | } |
| enum "mtunnel-fail-reason-bidir-assoc-id-missing" { | | enum "mtunnel-fail-reason-bidir-assoc-id-missing" { |
| description | | description |
| "Bidirectional is configured without Association | | "Bidirectional is configured without Association |
| ID"; | | ID"; |
| } | | } |
| enum "mtunnel-fail-reason-bfdgal-on-unidirectional" { | | enum "mtunnel-fail-reason-bfdgal-on-unidirectional" { |
| description | | description |
| "BFD GAL mode is supported on bidirectional | | "BFD GAL mode is supported on bidirectional |
| tunnels only"; | | tunnels only"; |
| } | | } |
| enum "mtunnel-fail-reason-destination-invalid" { | | enum "mtunnel-fail-reason-destination-invalid" { |
| description | | description |
| "Termination is supported with unnumbered | | "Termination is supported with unnumbered |
| destination only"; | | destination only"; |
| } | | } |
| enum "mtunnel-fail-reason-termination-bandwidth-mismatch" { | | enum "mtunnel-fail-reason-termination-bandwidth-mismatch" { |
| description | | description |
| "Termination bandwidth should match signalled | | "Termination bandwidth should match signalled |
| bandwidth"; | | bandwidth"; |
| } | | } |
| enum "mtunnel-fail-reason-termination-has-protection" { | | enum "mtunnel-fail-reason-termination-has-protection" { |
| description | | description |
| "Termination supports only working path-option"; | | "Termination supports only working path-option"; |
| } | | } |
| enum "mtunnel-fail-reason-termination-has-invalid-src-dest-ifindex" { | | enum "mtunnel-fail-reason-termination-has-invalid-src-dest-ifindex" { |
| description | | description |
| "Termination case must have source and | | "Termination case must have source and |
| destination valid ifindex"; | | destination valid ifindex"; |
| } | | } |
| enum "mtunnel-fail-reason-termination-has-invalid-payload-type" { | | enum "mtunnel-fail-reason-termination-has-invalid-payload-type" { |
| description | | description |
| "Termination payload type has to be valid for | | "Termination payload type has to be valid for |
| configured bandwidth"; | | configured bandwidth"; |
| } | | } |
| } | | } |
| description | | description |
| "Reason for tunnel being down"; | | "Reason for tunnel being down"; |
| } | | } |
| | | |
| typedef Mte-tunnel-oper-state { | | typedef Mte-tunnel-oper-state { |
| type enumeration { | | type enumeration { |
| enum "tunnel-state-oper-unknown" { | | enum "tunnel-state-oper-unknown" { |
| description | | description |
| "Tunnel is in unknown state"; | | "Tunnel is in unknown state"; |
| } | | } |
| enum "operational-down" { | | enum "operational-down" { |
| description | | description |
| "Tunnel is in operational down state"; | | "Tunnel is in operational down state"; |
| } | | } |
| enum "operational-up" { | | enum "operational-up" { |
| description | | description |
| "Tunnel is in operational up state"; | | "Tunnel is in operational up state"; |
| } | | } |
| } | | } |
| description | | description |
| "Tunnel operational state"; | | "Tunnel operational state"; |
| } | | } |
| | | |
| typedef Mte-tunnel-admin-state { | | typedef Mte-tunnel-admin-state { |
| type enumeration { | | type enumeration { |
| enum "tunnel-state-admin-unknown" { | | enum "tunnel-state-admin-unknown" { |
| description | | description |
| "Tunnel is in unknown state"; | | "Tunnel is in unknown state"; |
| } | | } |
| enum "admin-shutdown" { | | enum "admin-shutdown" { |
| description | | description |
| "Tunnel is in admin shutdown state"; | | "Tunnel is in admin shutdown state"; |
| } | | } |
| enum "admin-up" { | | enum "admin-up" { |
| description | | description |
| "Tunnel is in admin up state"; | | "Tunnel is in admin up state"; |
| } | | } |
| } | | } |
| description | | description |
| "Tunnel admin state"; | | "Tunnel admin state"; |
| } | | } |
| | | |
| typedef Te-vif-bfd-encap-mode { | | typedef Te-vif-bfd-encap-mode { |
| type enumeration { | | type enumeration { |
| enum "ip" { | | enum "ip" { |
| description | | description |
| "BFD Encap Mode IP"; | | "BFD Encap Mode IP"; |
| } | | } |
| enum "gal" { | | enum "gal" { |
| description | | description |
| "BFD Encap Mode GAL"; | | "BFD Encap Mode GAL"; |
| } | | } |
| } | | } |
| description | | description |
| "BFD Encap Mode"; | | "BFD Encap Mode"; |
| } | | } |
| | | |
| typedef Mpls-te-bfd-session-down-action1 { | | typedef Mpls-te-bfd-session-down-action1 { |
| type enumeration { | | type enumeration { |
| enum "reopt" { | | enum "reopt" { |
| value 0; | | value 0; |
| description | | description |
| "BFD session down action reoptimization"; | | "BFD session down action reoptimization"; |
| } | | } |
| enum "re-setup" { | | enum "re-setup" { |
| value 1; | | value 1; |
| description | | description |
| "BFD session down action tear down and resetup"; | | "BFD session down action tear down and resetup"; |
| } | | } |
| } | | } |
| description | | description |
| "BFD session down action"; | | "BFD session down action"; |
| } | | } |
| | | |
| typedef Te-lsp-path-protection-role { | | typedef Te-lsp-path-protection-role { |
| type enumeration { | | type enumeration { |
| enum "protection-role-not-set" { | | enum "protection-role-not-set" { |
| description | | description |
| "Protection role not set"; | | "Protection role not set"; |
| } | | } |
| enum "protection-role-working" { | | enum "protection-role-working" { |
| description | | description |
| "Working"; | | "Working"; |
| } | | } |
| enum "protection-role-protecting" { | | enum "protection-role-protecting" { |
| description | | description |
| "Protecting"; | | "Protecting"; |
| } | | } |
| enum "protection-role-pending" { | | enum "protection-role-pending" { |
| description | | description |
| "Pending"; | | "Pending"; |
| } | | } |
| } | | } |
| description | | description |
| "Protection Role"; | | "Protection Role"; |
| } | | } |
| | | |
| typedef Mte-reopt-trigger { | | typedef Mte-reopt-trigger { |
| type enumeration { | | type enumeration { |
| enum "no-trigger" { | | enum "no-trigger" { |
| description | | description |
| "No trigger"; | | "No trigger"; |
| } | | } |
| enum "timer-trigger" { | | enum "timer-trigger" { |
| description | | description |
| "Timer Trigger"; | | "Timer Trigger"; |
| } | | } |
| enum "bandwidth-change-trigger" { | | enum "bandwidth-change-trigger" { |
| description | | description |
| "Bandwidth Change Trigger"; | | "Bandwidth Change Trigger"; |
| } | | } |
| enum "auto-bandwidth-overflow-trigger" { | | enum "auto-bandwidth-overflow-trigger" { |
| description | | description |
| "Auto Bandwidth Overflow Trigger"; | | "Auto Bandwidth Overflow Trigger"; |
| } | | } |
| enum "auto-bandwidth-underflow-trigger" { | | enum "auto-bandwidth-underflow-trigger" { |
| description | | description |
| "Auto Bandwidth Underflow Trigger"; | | "Auto Bandwidth Underflow Trigger"; |
| } | | } |
| enum "auto-bandwidth-adjustment-trigger" { | | enum "auto-bandwidth-adjustment-trigger" { |
| description | | description |
| "Auto Bandwidth Adjustment Trigger"; | | "Auto Bandwidth Adjustment Trigger"; |
| } | | } |
| enum "metric-type-change-trigger" { | | enum "metric-type-change-trigger" { |
| description | | description |
| "Metric Type Change Trigger"; | | "Metric Type Change Trigger"; |
| } | | } |
| enum "user-trigger" { | | enum "user-trigger" { |
| description | | description |
| "User Trigger"; | | "User Trigger"; |
| } | | } |
| enum "frr-trigger" { | | enum "frr-trigger" { |
| description | | description |
| "FRR Trigger"; | | "FRR Trigger"; |
| } | | } |
| enum "remerge-error-trigger" { | | enum "remerge-error-trigger" { |
| description | | description |
| "Remerge Error Trigger"; | | "Remerge Error Trigger"; |
| } | | } |
| enum "preferred-path-trigger" { | | enum "preferred-path-trigger" { |
| description | | description |
| "Reception of the preferred path exists path | | "Reception of the preferred path exists path |
| error"; | | error"; |
| } | | } |
| enum "preferred-tree-trigger" { | | enum "preferred-tree-trigger" { |
| description | | description |
| "Reception of the preferred tree exists path | | "Reception of the preferred tree exists path |
| error"; | | error"; |
| } | | } |
| enum "due-to-maximum-metric" { | | enum "due-to-maximum-metric" { |
| description | | description |
| "Reoptimization triggered due to receiving an | | "Reoptimization triggered due to receiving an |
| LSA with MAX metric"; | | LSA with MAX metric"; |
| } | | } |
| enum "path-option-switchover-trigger" { | | enum "path-option-switchover-trigger" { |
| description | | description |
| "Path option switchover"; | | "Path option switchover"; |
| } | | } |
| enum "path-protection-switchover-trigger" { | | enum "path-protection-switchover-trigger" { |
| description | | description |
| "Path Protection Switchover Trigger"; | | "Path Protection Switchover Trigger"; |
| } | | } |
| enum "reroute-sticky-path-trigger" { | | enum "reroute-sticky-path-trigger" { |
| description | | description |
| "Reroute Sticky Path trigger"; | | "Reroute Sticky Path trigger"; |
| } | | } |
| enum "iep-enable-reoptimization-trigger" { | | enum "iep-enable-reoptimization-trigger" { |
| description | | description |
| "IEP Enable Reoptimization Trigger"; | | "IEP Enable Reoptimization Trigger"; |
| } | | } |
| enum "affinity-path-verification-fail-trigger" { | | enum "affinity-path-verification-fail-trigger" { |
| description | | description |
| "Affinity path verification failure trigger"; | | "Affinity path verification failure trigger"; |
| } | | } |
| enum "cost-limit-path-verification-fail-trigger" { | | enum "cost-limit-path-verification-fail-trigger" { |
| description | | description |
| "Cost limit path verification failure trigger"; | | "Cost limit path verification failure trigger"; |
| } | | } |
| enum "delay-limit-path-verification-fail-trigger" { | | enum "delay-limit-path-verification-fail-trigger" { |
| description | | description |
| "Delay limit path verification failure trigger"; | | "Delay limit path verification failure trigger"; |
| } | | } |
| enum "soft-preemption-trigger" { | | enum "soft-preemption-trigger" { |
| description | | description |
| "Soft preemption trigger"; | | "Soft preemption trigger"; |
| } | | } |
| enum "iep-changed" { | | enum "iep-changed" { |
| description | | description |
| "Explicit path has changed"; | | "Explicit path has changed"; |
| } | | } |
| enum "po-changed" { | | enum "po-changed" { |
| description | | description |
| "Path-option has changed"; | | "Path-option has changed"; |
| } | | } |
| enum "dest-changed" { | | enum "dest-changed" { |
| description | | description |
| "Destination has changed"; | | "Destination has changed"; |
| } | | } |
| enum "reopt-try-to-force-it" { | | enum "reopt-try-to-force-it" { |
| description | | description |
| "Reoptimization with try-to-force-it option"; | | "Reoptimization with try-to-force-it option"; |
| } | | } |
| enum "topology-change-trigger" { | | enum "topology-change-trigger" { |
| description | | description |
| "Topology change trigger"; | | "Topology change trigger"; |
| } | | } |
| enum "reopt-link-up-event" { | | enum "reopt-link-up-event" { |
| description | | description |
| "Topology link-up event trigger"; | | "Topology link-up event trigger"; |
| } | | } |
| enum "bfd-session-down-trigger" { | | enum "bfd-session-down-trigger" { |
| description | | description |
| "FRR enabled and BFD session down trigger"; | | "FRR enabled and BFD session down trigger"; |
| } | | } |
| enum "reverse-assoc-s2l-received-trigger" { | | enum "reverse-assoc-s2l-received-trigger" { |
| description | | description |
| "Reverse associated S2L received trigger"; | | "Reverse associated S2L received trigger"; |
| } | | } |
| enum "gmpls-uni-multilayer-trigger" { | | enum "gmpls-uni-multilayer-trigger" { |
| description | | description |
| "Multilayer recovery for GMPLS-UNI"; | | "Multilayer recovery for GMPLS-UNI"; |
| } | | } |
| enum "gmpls-uni-user-trigger" { | | enum "gmpls-uni-user-trigger" { |
| description | | description |
| "User-triggered GMPLS-UNI reopt request"; | | "User-triggered GMPLS-UNI reopt request"; |
| } | | } |
| enum "path-selection-tiebreaker-change-trigger" { | | enum "path-selection-tiebreaker-change-trigger" { |
| description | | description |
| "Path Selection Tiebreaker Change Trigger"; | | "Path Selection Tiebreaker Change Trigger"; |
| } | | } |
| enum "sr-egress-path-change-trigger" { | | enum "sr-egress-path-change-trigger" { |
| description | | description |
| "Segment-Routing Egress Path Change Trigger"; | | "Segment-Routing Egress Path Change Trigger"; |
| } | | } |
| enum "overload-bit-trigger" { | | enum "overload-bit-trigger" { |
| description | | description |
| "Overload-bit set on current path"; | | "Overload-bit set on current path"; |
| } | | } |
| enum "pce-trigger" { | | enum "pce-trigger" { |
| description | | description |
| "PCE Trigger"; | | "PCE Trigger"; |
| } | | } |
| enum "lockout-metric-trigger" { | | enum "lockout-metric-trigger" { |
| description | | description |
| "Reoptimization triggered due to receiving an | | "Reoptimization triggered due to receiving an |
| LSA with Lockout metric"; | | LSA with Lockout metric"; |
| } | | } |
| enum "bfd-session-config-change-trigger" { | | enum "bfd-session-config-change-trigger" { |
| description | | description |
| "BFD session configuration change"; | | "BFD session configuration change"; |
| } | | } |
| enum "higher-priority-po-change-trigger" { | | enum "higher-priority-po-change-trigger" { |
| description | | description |
| "Higher priority path option changed"; | | "Higher priority path option changed"; |
| } | | } |
| enum "sr-area-spf-support-change-trigger" { | | enum "sr-area-spf-support-change-trigger" { |
| description | | description |
| "Segment-Routing IGP Area SPF Support Change | | "Segment-Routing IGP Area SPF Support Change |
| Trigger"; | | Trigger"; |
| } | | } |
| enum "trigger-not-used" { | | enum "trigger-not-used" { |
| description | | description |
| "Not used"; | | "Not used"; |
| } | | } |
| } | | } |
| description | | description |
| "Reoptimization trigger"; | | "Reoptimization trigger"; |
| } | | } |
| | | |
| typedef Mpls-te-reopt-decision-reason { | | typedef Mpls-te-reopt-decision-reason { |
| type enumeration { | | type enumeration { |
| enum "decision-reason-none" { | | enum "decision-reason-none" { |
| value 0; | | value 0; |
| description | | description |
| "No reason"; | | "No reason"; |
| } | | } |
| enum "not-superset" { | | enum "not-superset" { |
| value 1; | | value 1; |
| description | | description |
| "Reopt LSP not signalled because it is not a | | "Reopt LSP not signalled because it is not a |
| superset of the current LSP"; | | superset of the current LSP"; |
| } | | } |
| enum "superset" { | | enum "superset" { |
| value 2; | | value 2; |
| description | | description |
| "Reopt LSP is signalled because it is a superset | | "Reopt LSP is signalled because it is a superset |
| of the current LSP"; | | of the current LSP"; |
| } | | } |
| enum "lsp-frr-active" { | | enum "lsp-frr-active" { |
| value 3; | | value 3; |
| description | | description |
| "Reopt LSP is signalled because the current LSP | | "Reopt LSP is signalled because the current LSP |
| is in FRR"; | | is in FRR"; |
| } | | } |
| enum "bandwidth-change" { | | enum "bandwidth-change" { |
| value 4; | | value 4; |
| description | | description |
| "Reopt LSP is signalled because there is a | | "Reopt LSP is signalled because there is a |
| bandwidth change"; | | bandwidth change"; |
| } | | } |
| enum "metric-type-change" { | | enum "metric-type-change" { |
| value 5; | | value 5; |
| description | | description |
| "Reopt LSP is signalled because there is a | | "Reopt LSP is signalled because there is a |
| metric type change"; | | metric type change"; |
| } | | } |
| enum "better-path-option-indexes" { | | enum "better-path-option-indexes" { |
| value 6; | | value 6; |
| description | | description |
| "Reopt LSP is signalled because it has better | | "Reopt LSP is signalled because it has better |
| path option indexes than the current LSP"; | | path option indexes than the current LSP"; |
| } | | } |
| enum "inter-area-preferred-path-exists" { | | enum "inter-area-preferred-path-exists" { |
| value 7; | | value 7; |
| description | | description |
| "Reopt LSP is signalled because an inter-area | | "Reopt LSP is signalled because an inter-area |
| preferred path exists"; | | preferred path exists"; |
| } | | } |
| enum "inter-area-preferred-tree-exists" { | | enum "inter-area-preferred-tree-exists" { |
| value 8; | | value 8; |
| description | | description |
| "Reopt LSP is signalled because an inter-area | | "Reopt LSP is signalled because an inter-area |
| preferred tree exists"; | | preferred tree exists"; |
| } | | } |
| enum "worse-path-option-indexes" { | | enum "worse-path-option-indexes" { |
| value 9; | | value 9; |
| description | | description |
| "Reopt LSP is not signalled because it has worse | | "Reopt LSP is not signalled because it has worse |
| path option indexes than the current LSP"; | | path option indexes than the current LSP"; |
| } | | } |
| enum "better-cumulative-metric" { | | enum "better-cumulative-metric" { |
| value 10; | | value 10; |
| description | | description |
| "Reopt LSP is signalled because it has better | | "Reopt LSP is signalled because it has better |
| path option indexes than the current LSP"; | | path option indexes than the current LSP"; |
| } | | } |
| enum "worse-cumulative-metric" { | | enum "worse-cumulative-metric" { |
| value 11; | | value 11; |
| description | | description |
| "Reopt LSP is not signalled because it has worse | | "Reopt LSP is not signalled because it has worse |
| cumulative metric than the current LSP"; | | cumulative metric than the current LSP"; |
| } | | } |
| enum "identical" { | | enum "identical" { |
| value 12; | | value 12; |
| description | | description |
| "Reopt LSP is not signalled because it is | | "Reopt LSP is not signalled because it is |
| identical to the current LSP"; | | identical to the current LSP"; |
| } | | } |
| enum "no-s2-ls" { | | enum "no-s2-ls" { |
| value 13; | | value 13; |
| description | | description |
| "Reopt LSP is not signalled because it has no | | "Reopt LSP is not signalled because it has no |
| S2Ls"; | | S2Ls"; |
| } | | } |
| enum "no-current-lsp" { | | enum "no-current-lsp" { |
| value 14; | | value 14; |
| description | | description |
| "Reopt LSP not signalled, no current LSP"; | | "Reopt LSP not signalled, no current LSP"; |
| } | | } |
| enum "user-path-option-switchover" { | | enum "user-path-option-switchover" { |
| value 15; | | value 15; |
| description | | description |
| "Reopt LSP signalled due to user requested | | "Reopt LSP signalled due to user requested |
| path-option switchover"; | | path-option switchover"; |
| } | | } |
| enum "better-hops" { | | enum "better-hops" { |
| value 16; | | value 16; |
| description | | description |
| "Reopt LSP is signalled because it has more S2Ls | | "Reopt LSP is signalled because it has more S2Ls |
| with less hops than the current LSP"; | | with less hops than the current LSP"; |
| } | | } |
| enum "worse-hops" { | | enum "worse-hops" { |
| value 17; | | value 17; |
| description | | description |
| "Reopt LSP is not signalled because it has less | | "Reopt LSP is not signalled because it has less |
| S2Ls with less hops than the current LSP"; | | S2Ls with less hops than the current LSP"; |
| } | | } |
| enum "pce-force" { | | enum "pce-force" { |
| value 18; | | value 18; |
| description | | description |
| "PCE based reoptimization triggered by CLI with | | "PCE based reoptimization triggered by CLI with |
| force option than the current LSP"; | | force option than the current LSP"; |
| } | | } |
| enum "affinity-changed" { | | enum "affinity-changed" { |
| value 19; | | value 19; |
| description | | description |
| "Reopt LSP is signalled because there is an | | "Reopt LSP is signalled because there is an |
| affinity change"; | | affinity change"; |
| } | | } |
| enum "cost-limit" { | | enum "cost-limit" { |
| value 20; | | value 20; |
| description | | description |
| "Reopt LSP is signalled because the path cost | | "Reopt LSP is signalled because the path cost |
| limit is crossed"; | | limit is crossed"; |
| } | | } |
| enum "sig-timeout" { | | enum "sig-timeout" { |
| value 21; | | value 21; |
| description | | description |
| "Re-opt LSP could not be signalled within | | "Re-opt LSP could not be signalled within |
| signalling timeout"; | | signalling timeout"; |
| } | | } |
| enum "not-superset-inst-timer-expired" { | | enum "not-superset-inst-timer-expired" { |
| value 22; | | value 22; |
| description | | description |
| "Re-opt LSP is not a superset when the install | | "Re-opt LSP is not a superset when the install |
| timer expired"; | | timer expired"; |
| } | | } |
| enum "path-verifiction-failed" { | | enum "path-verifiction-failed" { |
| value 23; | | value 23; |
| description | | description |
| "Re-opt LSP path verification failed"; | | "Re-opt LSP path verification failed"; |
| } | | } |
| enum "soft-preemption-recovery" { | | enum "soft-preemption-recovery" { |
| value 24; | | value 24; |
| description | | description |
| "Re-opt LSP is signalled because of soft | | "Re-opt LSP is signalled because of soft |
| preemption recovery"; | | preemption recovery"; |
| } | | } |
| enum "iep-changed" { | | enum "iep-changed" { |
| value 25; | | value 25; |
| description | | description |
| "Re-opt LSP is signalled because the inuse | | "Re-opt LSP is signalled because the inuse |
| explicit-path has changed"; | | explicit-path has changed"; |
| } | | } |
| enum "po-changed" { | | enum "po-changed" { |
| value 26; | | value 26; |
| description | | description |
| "Re-opt LSP is signalled because the inuse | | "Re-opt LSP is signalled because the inuse |
| path-option has changed"; | | path-option has changed"; |
| } | | } |
| enum "dest-changed" { | | enum "dest-changed" { |
| value 27; | | value 27; |
| description | | description |
| "Re-opt LSP is signalled because the destination | | "Re-opt LSP is signalled because the destination |
| has changed"; | | has changed"; |
| } | | } |
| enum "better-igp-area" { | | enum "better-igp-area" { |
| value 28; | | value 28; |
| description | | description |
| "Reopt LSP is signalled because its path was | | "Reopt LSP is signalled because its path was |
| calculated in a preferred IGP-area to the | | calculated in a preferred IGP-area to the |
| current LSP"; | | current LSP"; |
| } | | } |
| enum "worse-igp-area" { | | enum "worse-igp-area" { |
| value 29; | | value 29; |
| description | | description |
| "Reopt LSP is not signalled because its path was | | "Reopt LSP is not signalled because its path was |
| calculated in a worse IGP-area than the current | | calculated in a worse IGP-area than the current |
| LSP"; | | LSP"; |
| } | | } |
| enum "better-bandwidth-load-balancing" { | | enum "better-bandwidth-load-balancing" { |
| value 30; | | value 30; |
| description | | description |
| "Reopt LSP is signalled because it gives better | | "Reopt LSP is signalled because it gives better |
| bandwidth load balancing than the current LSP"; | | bandwidth load balancing than the current LSP"; |
| } | | } |
| enum "worse-bandwidth-load-balancing" { | | enum "worse-bandwidth-load-balancing" { |
| value 31; | | value 31; |
| description | | description |
| "Reopt LSP is not signalled because it gives | | "Reopt LSP is not signalled because it gives |
| worse bandwidth load balancing than the current | | worse bandwidth load balancing than the current |
| LSP"; | | LSP"; |
| } | | } |
| enum "bfd-session-down" { | | enum "bfd-session-down" { |
| value 32; | | value 32; |
| description | | description |
| "Reopt LSP is signaled because BFD sesssion went | | "Reopt LSP is signaled because BFD sesssion went |
| down"; | | down"; |
| } | | } |
| enum "auto-pcc-reopt" { | | enum "auto-pcc-reopt" { |
| value 33; | | value 33; |
| description | | description |
| "Re-opt LSP is signalled because it was | | "Re-opt LSP is signalled because it was |
| triggered by a PCE"; | | triggered by a PCE"; |
| } | | } |
| enum "sr-egress-path-changed" { | | enum "sr-egress-path-changed" { |
| value 34; | | value 34; |
| description | | description |
| "Reopt LSP is signaled because the egress | | "Reopt LSP is signaled because the egress |
| path(s) changed"; | | path(s) changed"; |
| } | | } |
| enum "overload-bit-set" { | | enum "overload-bit-set" { |
| value 35; | | value 35; |
| description | | description |
| "Reopt LSP is signalled because the current LSP | | "Reopt LSP is signalled because the current LSP |
| uses an OL node"; | | uses an OL node"; |
| } | | } |
| enum "better-diversity" { | | enum "better-diversity" { |
| value 36; | | value 36; |
| description | | description |
| "Reopt LSP is signalled because it has better | | "Reopt LSP is signalled because it has better |
| diversity than the current LSP"; | | diversity than the current LSP"; |
| } | | } |
| enum "worse-diversity" { | | enum "worse-diversity" { |
| value 37; | | value 37; |
| description | | description |
| "Reopt LSP is not signalled because it has worse | | "Reopt LSP is not signalled because it has worse |
| diversity than the current lsp"; | | diversity than the current lsp"; |
| } | | } |
| enum "bfd-session-type-changed" { | | enum "bfd-session-type-changed" { |
| value 38; | | value 38; |
| description | | description |
| "Reopt LSP is signalled because BFD sesssion | | "Reopt LSP is signalled because BFD sesssion |
| tyep is changed"; | | tyep is changed"; |
| } | | } |
| enum "lsp-drop-mode" { | | enum "lsp-drop-mode" { |
| value 39; | | value 39; |
| description | | description |
| "Reopt LSP is signalled because current LSP is | | "Reopt LSP is signalled because current LSP is |
| in drop mode"; | | in drop mode"; |
| } | | } |
| enum "strict-spf" { | | enum "strict-spf" { |
| value 40; | | value 40; |
| description | | description |
| "Reopt LSP is signalled because it uses strict | | "Reopt LSP is signalled because it uses strict |
| SPF while current doesn't"; | | SPF while current doesn't"; |
| } | | } |
| enum "delay-limit" { | | enum "delay-limit" { |
| value 41; | | value 41; |
| description | | description |
| "Reopt LSP is signalled because the path delay | | "Reopt LSP is signalled because the path delay |
| limit is crossed"; | | limit is crossed"; |
| } | | } |
| enum "lockout-metric" { | | enum "lockout-metric" { |
| value 42; | | value 42; |
| description | | description |
| "Reopt LSP is signalled because one of the | | "Reopt LSP is signalled because one of the |
| links is locked out"; | | links is locked out"; |
| } | | } |
| enum "intra-area" { | | enum "intra-area" { |
| value 43; | | value 43; |
| description | | description |
| "Reopt LSP is signalled because it has better | | "Reopt LSP is signalled because it has better |
| intra-areaness"; | | intra-areaness"; |
| } | | } |
| enum "clear-sticky" { | | enum "clear-sticky" { |
| value 44; | | value 44; |
| description | | description |
| "Reopt LSP is signalled because clear sticky | | "Reopt LSP is signalled because clear sticky |
| command"; | | command"; |
| } | | } |
| enum "not-used" { | | enum "not-used" { |
| value 45; | | value 45; |
| description | | description |
| "Not used, must be last entry"; | | "Not used, must be last entry"; |
| } | | } |
| } | | } |
| description | | description |
| "Reoptimization decision"; | | "Reoptimization decision"; |
| } | | } |
| | | |
| typedef Mpls-te-lsp-wrap-state { | | typedef Mpls-te-lsp-wrap-state { |
| type enumeration { | | type enumeration { |
| enum "lsp-wrap-not-ready" { | | enum "lsp-wrap-not-ready" { |
| description | | description |
| "LSP Wrap state is not ready"; | | "LSP Wrap state is not ready"; |
| } | | } |
| enum "lsp-wrap-active" { | | enum "lsp-wrap-active" { |
| description | | description |
| "LSP Wrap state is active"; | | "LSP Wrap state is active"; |
| } | | } |
| enum "lsp-wrap-ready" { | | enum "lsp-wrap-ready" { |
| description | | description |
| "LSP Wrap state is ready"; | | "LSP Wrap state is ready"; |
| } | | } |
| } | | } |
| description | | description |
| "LSP Wrap state"; | | "LSP Wrap state"; |
| } | | } |
| | | |
| typedef Te-sr-sid { | | typedef Te-sr-sid { |
| type enumeration { | | type enumeration { |
| enum "srsid-not-set" { | | enum "srsid-not-set" { |
| description | | description |
| "Type not set"; | | "Type not set"; |
| } | | } |
| enum "srsid-node" { | | enum "srsid-node" { |
| description | | description |
| "Segment-Routing Node"; | | "Segment-Routing Node"; |
| } | | } |
| enum "srsid-adj" { | | enum "srsid-adj" { |
| description | | description |
| "Segment-Routing Link"; | | "Segment-Routing Link"; |
| } | | } |
| enum "srsid-unknown" { | | enum "srsid-unknown" { |
| description | | description |
| "Segment-Routing Unknown"; | | "Segment-Routing Unknown"; |
| } | | } |
| } | | } |
| description | | description |
| "Segment-Routing SID types"; | | "Segment-Routing SID types"; |
| } | | } |
| | | |
| typedef Te-association-tie-role { | | typedef Te-association-tie-role { |
| type enumeration { | | type enumeration { |
| enum "none" { | | enum "none" { |
| description | | description |
| "Association Role None"; | | "Association Role None"; |
| } | | } |
| enum "master" { | | enum "master" { |
| description | | description |
| "Association Role Master"; | | "Association Role Master"; |
| } | | } |
| enum "slave" { | | enum "slave" { |
| description | | description |
| "Association Role Slave"; | | "Association Role Slave"; |
| } | | } |
| } | | } |
| description | | description |
| "TE Association Tie Breaker Role"; | | "TE Association Tie Breaker Role"; |
| } | | } |
| | | |
| typedef Te-vif-bfd { | | typedef Te-vif-bfd { |
| type enumeration { | | type enumeration { |
| enum "bfd-disabled" { | | enum "bfd-disabled" { |
| value 0; | | value 0; |
| description | | description |
| "BFD Fast Detect Not Enabled"; | | "BFD Fast Detect Not Enabled"; |
| } | | } |
| enum "bfd-enabled" { | | enum "bfd-enabled" { |
| value 1; | | value 1; |
| description | | description |
| "Regular BFD Enabled"; | | "Regular BFD Enabled"; |
| } | | } |
| enum "sbfd-enabled" { | | enum "sbfd-enabled" { |
| value 2; | | value 2; |
| description | | description |
| "SBFD Enabled"; | | "SBFD Enabled"; |
| } | | } |
| } | | } |
| description | | description |
| "BFD Type"; | | "BFD Type"; |
| } | | } |
| | | |
| typedef Te-bfd-lsp-session-state { | | typedef Te-bfd-lsp-session-state { |
| type enumeration { | | type enumeration { |
| enum "bfd-over-lsp-session-state-none" { | | enum "bfd-over-lsp-session-state-none" { |
| value 0; | | value 0; |
| description | | description |
| "BFDOverLSP session state none"; | | "BFDOverLSP session state none"; |
| } | | } |
| enum "bfd-over-lsp-session-state-created" { | | enum "bfd-over-lsp-session-state-created" { |
| value 1; | | value 1; |
| description | | description |
| "BFDOverLSP session state created"; | | "BFDOverLSP session state created"; |
| } | | } |
| enum "bfd-over-lsp-session-state-up" { | | enum "bfd-over-lsp-session-state-up" { |
| value 2; | | value 2; |
| description | | description |
| "BFDOverLSP session state up"; | | "BFDOverLSP session state up"; |
| } | | } |
| enum "bfd-over-lsp-session-state-down" { | | enum "bfd-over-lsp-session-state-down" { |
| value 3; | | value 3; |
| description | | description |
| "BFDOverLSP session state down"; | | "BFDOverLSP session state down"; |
| } | | } |
| enum "bfd-over-lsp-session-state-admin-down" { | | enum "bfd-over-lsp-session-state-admin-down" { |
| value 4; | | value 4; |
| description | | description |
| "BFDOverLSP session state admin down"; | | "BFDOverLSP session state admin down"; |
| } | | } |
| enum "bfd-over-lsp-session-state-deleted" { | | enum "bfd-over-lsp-session-state-deleted" { |
| value 5; | | value 5; |
| description | | description |
| "BFDOverLSP sesssion state deleted"; | | "BFDOverLSP sesssion state deleted"; |
| } | | } |
| enum "bfd-over-lsp-session-state-create-failed" { | | enum "bfd-over-lsp-session-state-create-failed" { |
| value 6; | | value 6; |
| description | | description |
| "BFDOverLSP session state create failed"; | | "BFDOverLSP session state create failed"; |
| } | | } |
| } | | } |
| description | | description |
| "TE BFDOverLSP Session State"; | | "TE BFDOverLSP Session State"; |
| } | | } |
| | | |
| typedef Gmpls-uni-mgmt-dwdm-cs { | | typedef Gmpls-uni-mgmt-dwdm-cs { |
| type enumeration { | | type enumeration { |
| enum "not-set" { | | enum "not-set" { |
| description | | description |
| "Not Set"; | | "Not Set"; |
| } | | } |
| enum "dwdm100g-hz" { | | enum "dwdm100g-hz" { |
| description | | description |
| "100GHz"; | | "100GHz"; |
| } | | } |
| enum "dwdm50g-hz" { | | enum "dwdm50g-hz" { |
| description | | description |
| "50GHz"; | | "50GHz"; |
| } | | } |
| enum "dwdm25g-hz" { | | enum "dwdm25g-hz" { |
| description | | description |
| "25GHz"; | | "25GHz"; |
| } | | } |
| enum "dwdm12g-hz" { | | enum "dwdm12g-hz" { |
| description | | description |
| "12.5GHz"; | | "12.5GHz"; |
| } | | } |
| enum "dwdm6g-hz" { | | enum "dwdm6g-hz" { |
| description | | description |
| "6.25GHz"; | | "6.25GHz"; |
| } | | } |
| } | | } |
| description | | description |
| "GMPLS-UNI DWDM channel spacings"; | | "GMPLS-UNI DWDM channel spacings"; |
| } | | } |
| | | |
| typedef Gmpls-uni-mgmt-wdm-grid { | | typedef Gmpls-uni-mgmt-wdm-grid { |
| type enumeration { | | type enumeration { |
| enum "not-set" { | | enum "not-set" { |
| description | | description |
| "Not Set"; | | "Not Set"; |
| } | | } |
| enum "dwdm" { | | enum "dwdm" { |
| description | | description |
| "DWDM"; | | "DWDM"; |
| } | | } |
| enum "cwdm" { | | enum "cwdm" { |
| description | | description |
| "CWDM"; | | "CWDM"; |
| } | | } |
| } | | } |
| description | | description |
| "GMPLS-UNI WDM grid"; | | "GMPLS-UNI WDM grid"; |
| } | | } |
| | | |
| typedef Mpls-te-mgmt-gmpls-label { | | typedef Mpls-te-mgmt-gmpls-label { |
| type enumeration { | | type enumeration { |
| enum "not-set" { | | enum "not-set" { |
| description | | description |
| "Not Set"; | | "Not Set"; |
| } | | } |
| enum "fixed-wdm" { | | enum "fixed-wdm" { |
| description | | description |
| "Fixed-grid WDM"; | | "Fixed-grid WDM"; |
| } | | } |
| enum "fixed-g709otn" { | | enum "fixed-g709otn" { |
| description | | description |
| "Fixed-size G709 OTN"; | | "Fixed-size G709 OTN"; |
| } | | } |
| enum "fsc" { | | enum "fsc" { |
| description | | description |
| "Fiber Switch"; | | "Fiber Switch"; |
| } | | } |
| } | | } |
| description | | description |
| "GMPLS label type"; | | "GMPLS label type"; |
| } | | } |
| | | |
| typedef Mpls-te-soft-preemption-state { | | typedef Mpls-te-soft-preemption-state { |
| type enumeration { | | type enumeration { |
| enum "soft-preemption-not-pending" { | | enum "soft-preemption-not-pending" { |
| description | | description |
| "Soft Preemption has not been triggered and is | | "Soft Preemption has not been triggered and is |
| not pending"; | | not pending"; |
| } | | } |
| enum "soft-preemption-pending" { | | enum "soft-preemption-pending" { |
| description | | description |
| "Soft Preemption has been triggered and is | | "Soft Preemption has been triggered and is |
| pending"; | | pending"; |
| } | | } |
| } | | } |
| description | | description |
| "The possible states for soft preemption"; | | "The possible states for soft preemption"; |
| } | | } |
| | | |
| typedef Mpls-te-tunnels-signaling-status { | | typedef Mpls-te-tunnels-signaling-status { |
| type enumeration { | | type enumeration { |
| enum "down" { | | enum "down" { |
| description | | description |
| "The tunnel is down"; | | "The tunnel is down"; |
| } | | } |
| enum "recovering" { | | enum "recovering" { |
| description | | description |
| "The tunnel is recovering"; | | "The tunnel is recovering"; |
| } | | } |
| enum "recovered" { | | enum "recovered" { |
| description | | description |
| "The tunnel is recovered"; | | "The tunnel is recovered"; |
| } | | } |
| enum "connected" { | | enum "connected" { |
| description | | description |
| "The tunnel is connected"; | | "The tunnel is connected"; |
| } | | } |
| enum "disabled" { | | enum "disabled" { |
| description | | description |
| "The tunnel signalling is disabled"; | | "The tunnel signalling is disabled"; |
| } | | } |
| enum "proceeding" { | | enum "proceeding" { |
| description | | description |
| "The tunnel signalling is proceeding"; | | "The tunnel signalling is proceeding"; |
| } | | } |
| enum "wait-bfd-session-up" { | | enum "wait-bfd-session-up" { |
| description | | description |
| "The tunnel is waiting for BFD session up"; | | "The tunnel is waiting for BFD session up"; |
| } | | } |
| enum "wait-sr-segment-path-up" { | | enum "wait-sr-segment-path-up" { |
| description | | description |
| "The tunnel is waiting for SR segment path"; | | "The tunnel is waiting for SR segment path"; |
| } | | } |
| enum "wait-local-label" { | | enum "wait-local-label" { |
| description | | description |
| "The tunnel is waiting for a local label"; | | "The tunnel is waiting for a local label"; |
| } | | } |
| enum "wait-local-label-rewrite" { | | enum "wait-local-label-rewrite" { |
| description | | description |
| "The tunnel is waiting for a local label rewrite"; | | "The tunnel is waiting for a local label rewrite"; |
| } | | } |
| } | | } |
| description | | description |
| "Tunnel signalling status"; | | "Tunnel signalling status"; |
| } | | } |
| | | |
| typedef Mpls-te-frr-state { | | typedef Mpls-te-frr-state { |
| type enumeration { | | type enumeration { |
| enum "frr-inactive" { | | enum "frr-inactive" { |
| description | | description |
| "FRR state is inactive"; | | "FRR state is inactive"; |
| } | | } |
| enum "frr-active" { | | enum "frr-active" { |
| description | | description |
| "FRR state is active"; | | "FRR state is active"; |
| } | | } |
| enum "frr-ready" { | | enum "frr-ready" { |
| description | | description |
| "FRR state is ready"; | | "FRR state is ready"; |
| } | | } |
| } | | } |
| description | | description |
| "FRR state"; | | "FRR state"; |
| } | | } |
| | | |
| typedef Te-controller-state { | | typedef Te-controller-state { |
| type enumeration { | | type enumeration { |
| enum "notready" { | | enum "notready" { |
| description | | description |
| "Controller not ready"; | | "Controller not ready"; |
| } | | } |
| enum "admin-down" { | | enum "admin-down" { |
| description | | description |
| "Controller is admin down"; | | "Controller is admin down"; |
| } | | } |
| enum "down" { | | enum "down" { |
| description | | description |
| "Controller is operationally down"; | | "Controller is operationally down"; |
| } | | } |
| enum "shutdown" { | | enum "shutdown" { |
| description | | description |
| "Controller is shutdown"; | | "Controller is shutdown"; |
| } | | } |
| enum "error-disabled" { | | enum "error-disabled" { |
| description | | description |
| "Controller is disabled due to error"; | | "Controller is disabled due to error"; |
| } | | } |
| enum "up" { | | enum "up" { |
| description | | description |
| "Controller is operationally up"; | | "Controller is operationally up"; |
| } | | } |
| enum "unknown" { | | enum "unknown" { |
| description | | description |
| "Controller state unknown"; | | "Controller state unknown"; |
| } | | } |
| } | | } |
| description | | description |
| "Controller States"; | | "Controller States"; |
| } | | } |
| | | |
| typedef Te-mgmt-generic-fspec { | | typedef Te-mgmt-generic-fspec { |
| type enumeration { | | type enumeration { |
| enum "te-generic-fspec-type-g709otn" { | | enum "te-generic-fspec-type-g709otn" { |
| description | | description |
| "TE G709 OTN FSpec type"; | | "TE G709 OTN FSpec type"; |
| } | | } |
| } | | } |
| description | | description |
| "TE generic FSpec types"; | | "TE generic FSpec types"; |
| } | | } |
| | | |
| typedef Te-mgmt-generic-tspec { | | typedef Te-mgmt-generic-tspec { |
| type enumeration { | | type enumeration { |
| enum "te-generic-tspec-type-g709otn" { | | enum "te-generic-tspec-type-g709otn" { |
| description | | description |
| "TE G709 OTN TSpec type"; | | "TE G709 OTN TSpec type"; |
| } | | } |
| } | | } |
| description | | description |
| "TE generic TSpec types"; | | "TE generic TSpec types"; |
| } | | } |
| | | |
| typedef Rsvp-mgmt-rro-subobj { | | typedef Rsvp-mgmt-rro-subobj { |
| type enumeration { | | type enumeration { |
| enum "ipv4rro-type" { | | enum "ipv4rro-type" { |
| value 1; | | value 1; |
| description | | description |
| "IPv4 RRO Type"; | | "IPv4 RRO Type"; |
| } | | } |
| enum "label-rro-type" { | | enum "label-rro-type" { |
| value 3; | | value 3; |
| description | | description |
| "Label RRO Type"; | | "Label RRO Type"; |
| } | | } |
| enum "unnumbered-rro-type" { | | enum "unnumbered-rro-type" { |
| value 4; | | value 4; |
| description | | description |
| "Unnumbered RRO Type"; | | "Unnumbered RRO Type"; |
| } | | } |
| enum "srlg-rro-type" { | | enum "srlg-rro-type" { |
| value 34; | | value 34; |
| description | | description |
| "SRLG RRO Type"; | | "SRLG RRO Type"; |
| } | | } |
| } | | } |
| description | | description |
| "RSVP RRO Types"; | | "RSVP RRO Types"; |
| } | | } |
| | | |
| typedef Rsvp-mgmt-ero-subobj-status { | | typedef Rsvp-mgmt-ero-subobj-status { |
| type enumeration { | | type enumeration { |
| enum "rsvp-mgmt-ero-status-not-available" { | | enum "rsvp-mgmt-ero-status-not-available" { |
| value 0; | | value 0; |
| description | | description |
| "ERO is not available in topology"; | | "ERO is not available in topology"; |
| } | | } |
| enum "rsvp-mgmt-ero-status-available" { | | enum "rsvp-mgmt-ero-status-available" { |
| value 1; | | value 1; |
| description | | description |
| "ERO is available in topology"; | | "ERO is available in topology"; |
| } | | } |
| enum "rsvp-mgmt-ero-status-bw-not-available" { | | enum "rsvp-mgmt-ero-status-bw-not-available" { |
| value 2; | | value 2; |
| description | | description |
| "ERO doesn't have bw available in topology"; | | "ERO doesn't have bw available in topology"; |
| } | | } |
| } | | } |
| description | | description |
| "RSVP ERO Status"; | | "RSVP ERO Status"; |
| } | | } |
| | | |
| typedef Rsvp-mgmt-ero-subobj { | | typedef Rsvp-mgmt-ero-subobj { |
| type enumeration { | | type enumeration { |
| enum "rsvp-mgmt-ero-type-ipv4" { | | enum "rsvp-mgmt-ero-type-ipv4" { |
| value 1; | | value 1; |
| description | | description |
| "IPv4 ERO Type"; | | "IPv4 ERO Type"; |
| } | | } |
| enum "rsvp-mgmt-ero-type-un-num" { | | enum "rsvp-mgmt-ero-type-un-num" { |
| value 4; | | value 4; |
| description | | description |
| "Unnumbered ERO Type"; | | "Unnumbered ERO Type"; |
| } | | } |
| } | | } |
| description | | description |
| "RSVP ERO Types"; | | "RSVP ERO Types"; |
| } | | } |
| | | |
| typedef Mpls-te-metric { | | typedef Mpls-te-metric { |
| type enumeration { | | type enumeration { |
| enum "metric-not-set" { | | enum "metric-not-set" { |
| description | | description |
| "Metric type not set"; | | "Metric type not set"; |
| } | | } |
| enum "metric-igp" { | | enum "metric-igp" { |
| description | | description |
| "Metric for IGP routes"; | | "Metric for IGP routes"; |
| } | | } |
| enum "metric-te" { | | enum "metric-te" { |
| description | | description |
| "Metric for MPLS traffic engineering tunnels"; | | "Metric for MPLS traffic engineering tunnels"; |
| } | | } |
| enum "metric-delay" { | | enum "metric-delay" { |
| description | | description |
| "Delay Metric"; | | "Delay Metric"; |
| } | | } |
| } | | } |
| description | | description |
| "Metric type"; | | "Metric type"; |
| } | | } |
| | | |
| typedef Te-path-inval-action { | | typedef Te-path-inval-action { |
| type enumeration { | | type enumeration { |
| enum "none" { | | enum "none" { |
| value 0; | | value 0; |
| description | | description |
| "TE path selection invalidation action none"; | | "TE path selection invalidation action none"; |
| } | | } |
| enum "tear" { | | enum "tear" { |
| value 1; | | value 1; |
| description | | description |
| "TE path selection invalidation action tear"; | | "TE path selection invalidation action tear"; |
| } | | } |
| enum "drop" { | | enum "drop" { |
| value 2; | | value 2; |
| description | | description |
| "TE path selection invalidation action drop"; | | "TE path selection invalidation action drop"; |
| } | | } |
| } | | } |
| description | | description |
| "Path selection invalidation action type"; | | "Path selection invalidation action type"; |
| } | | } |
| | | |
| typedef Te-s2l-sr-path-selection { | | typedef Te-s2l-sr-path-selection { |
| type enumeration { | | type enumeration { |
| enum "te-s2l-sr-path-selection-any" { | | enum "te-s2l-sr-path-selection-any" { |
| value 0; | | value 0; |
| description | | description |
| "TE S2L Segment-Routing Path Selection type Any"; | | "TE S2L Segment-Routing Path Selection type Any"; |
| } | | } |
| enum "te-s2l-sr-path-selection-adj-unprotected" { | | enum "te-s2l-sr-path-selection-adj-unprotected" { |
| value 1; | | value 1; |
| description | | description |
| "TE S2L Segment-Routing Path Selection type | | "TE S2L Segment-Routing Path Selection type |
| Adjacency Unprotected"; | | Adjacency Unprotected"; |
| } | | } |
| enum "te-s2l-sr-path-selection-adj-protected" { | | enum "te-s2l-sr-path-selection-adj-protected" { |
| value 2; | | value 2; |
| description | | description |
| "TE S2L Segment-Routing Path Selection type | | "TE S2L Segment-Routing Path Selection type |
| Adjacency Protected"; | | Adjacency Protected"; |
| } | | } |
| } | | } |
| description | | description |
| "Segment-routing path selection type"; | | "Segment-routing path selection type"; |
| } | | } |
| | | |
| typedef Te-bfd-reverse-path { | | typedef Te-bfd-reverse-path { |
| type enumeration { | | type enumeration { |
| enum "bfd-reverse-path-none" { | | enum "bfd-reverse-path-none" { |
| value 0; | | value 0; |
| description | | description |
| "BFD reverse path not enabled"; | | "BFD reverse path not enabled"; |
| } | | } |
| enum "bfd-reverse-path-binding-label" { | | enum "bfd-reverse-path-binding-label" { |
| value 1; | | value 1; |
| description | | description |
| "BFD reverse path binding label"; | | "BFD reverse path binding label"; |
| } | | } |
| } | | } |
| description | | description |
| "BFD Reverse Path Type"; | | "BFD Reverse Path Type"; |
| } | | } |
| | | |
| typedef Te-pce-disjoint { | | typedef Te-pce-disjoint { |
| type enumeration { | | type enumeration { |
| enum "none" { | | enum "none" { |
| value 0; | | value 0; |
| description | | description |
| "PCE Disjoint Type none"; | | "PCE Disjoint Type none"; |
| } | | } |
| enum "link" { | | enum "link" { |
| value 1; | | value 1; |
| description | | description |
| "PCE Disjoint Type link"; | | "PCE Disjoint Type link"; |
| } | | } |
| enum "node" { | | enum "node" { |
| value 2; | | value 2; |
| description | | description |
| "PCE Disjoint Type node"; | | "PCE Disjoint Type node"; |
| } | | } |
| enum "srlg" { | | enum "srlg" { |
| value 3; | | value 3; |
| description | | description |
| "PCE Disjoint Type srlg"; | | "PCE Disjoint Type srlg"; |
| } | | } |
| } | | } |
| description | | description |
| "PCE Disjoint Path type"; | | "PCE Disjoint Path type"; |
| } | | } |
| | | |
| typedef Tunnel-attribute-set { | | typedef Tunnel-attribute-set { |
| type enumeration { | | type enumeration { |
| enum "tunnel-attribute-set-none" { | | enum "tunnel-attribute-set-none" { |
| value 0; | | value 0; |
| description | | description |
| "No Tunnel AttributeSet configured"; | | "No Tunnel AttributeSet configured"; |
| } | | } |
| enum "tunnel-attribute-set-static" { | | enum "tunnel-attribute-set-static" { |
| value 1; | | value 1; |
| description | | description |
| "Tunnel AttributeSet Type is Static"; | | "Tunnel AttributeSet Type is Static"; |
| } | | } |
| enum "tunnel-attribute-set-path-option" { | | enum "tunnel-attribute-set-path-option" { |
| value 2; | | value 2; |
| description | | description |
| "Tunnel AttributeSet Type is Path Option"; | | "Tunnel AttributeSet Type is Path Option"; |
| } | | } |
| enum "tunnel-attribute-set-not-used" { | | enum "tunnel-attribute-set-not-used" { |
| value 3; | | value 3; |
| description | | description |
| "None"; | | "None"; |
| } | | } |
| enum "tunnel-attribute-set-auto-backup" { | | enum "tunnel-attribute-set-auto-backup" { |
| value 4; | | value 4; |
| description | | description |
| "Tunnel AttributeSet Type is AutoBackup"; | | "Tunnel AttributeSet Type is AutoBackup"; |
| } | | } |
| enum "tunnel-attribute-set-auto-mesh" { | | enum "tunnel-attribute-set-auto-mesh" { |
| value 5; | | value 5; |
| description | | description |
| "Tunnel AttributeSet Type is AutoMesh"; | | "Tunnel AttributeSet Type is AutoMesh"; |
| } | | } |
| enum "tunnel-attribute-set-xro" { | | enum "tunnel-attribute-set-xro" { |
| value 6; | | value 6; |
| description | | description |
| "Tunnel AttributeSet Type is XRO"; | | "Tunnel AttributeSet Type is XRO"; |
| } | | } |
| enum "tunnel-attribute-set-p2mpte" { | | enum "tunnel-attribute-set-p2mpte" { |
| value 7; | | value 7; |
| description | | description |
| "Tunnel AttributeSet Type is P2MP TE"; | | "Tunnel AttributeSet Type is P2MP TE"; |
| } | | } |
| enum "tunnel-attribute-aps-pp" { | | enum "tunnel-attribute-aps-pp" { |
| value 8; | | value 8; |
| description | | description |
| "Tunnel AttributeSet Type is APS Path Protection"; | | "Tunnel AttributeSet Type is APS Path Protection"; |
| } | | } |
| enum "tunnel-attribute-set-p2p-te" { | | enum "tunnel-attribute-set-p2p-te" { |
| value 9; | | value 9; |
| description | | description |
| "Tunnel AttributeSet Type is P2P TE"; | | "Tunnel AttributeSet Type is P2P TE"; |
| } | | } |
| enum "tunnel-attribute-uni-p" { | | enum "tunnel-attribute-uni-p" { |
| value 10; | | value 10; |
| description | | description |
| "Tunnel AttributeSet Type is UNI Protection"; | | "Tunnel AttributeSet Type is UNI Protection"; |
| } | | } |
| } | | } |
| description | | description |
| "Tunnel attribute set"; | | "Tunnel attribute set"; |
| } | | } |
| | | |
| typedef Mpls-te-pathoption { | | typedef Mpls-te-pathoption { |
| type enumeration { | | type enumeration { |
| enum "path-option-unknown" { | | enum "path-option-unknown" { |
| description | | description |
| "Unknown Path Option"; | | "Unknown Path Option"; |
| } | | } |
| enum "path-option-dynamic" { | | enum "path-option-dynamic" { |
| description | | description |
| "Dynamic Path Option"; | | "Dynamic Path Option"; |
| } | | } |
| enum "path-option-explicit-name" { | | enum "path-option-explicit-name" { |
| description | | description |
| "Explicit name Path Option"; | | "Explicit name Path Option"; |
| } | | } |
| enum "path-option-explicit-id" { | | enum "path-option-explicit-id" { |
| description | | description |
| "Explicit Identifier Path Option"; | | "Explicit Identifier Path Option"; |
| } | | } |
| enum "path-option-pce" { | | enum "path-option-pce" { |
| description | | description |
| "PCE Path Option"; | | "PCE Path Option"; |
| } | | } |
| enum "path-option-no-ero" { | | enum "path-option-no-ero" { |
| description | | description |
| "No-ERO Path Option"; | | "No-ERO Path Option"; |
| } | | } |
| enum "path-option-segment-routing" { | | enum "path-option-segment-routing" { |
| description | | description |
| "Segment-Routing Path Option"; | | "Segment-Routing Path Option"; |
| } | | } |
| } | | } |
| description | | description |
| "Path-option type"; | | "Path-option type"; |
| } | | } |
| | | |
| typedef Mpls-te-bw-pool { | | typedef Mpls-te-bw-pool { |
| type enumeration { | | type enumeration { |
| enum "te-bandwidth-pool0" { | | enum "te-bandwidth-pool0" { |
| description | | description |
| "Bandwidth pool type is pool0"; | | "Bandwidth pool type is pool0"; |
| } | | } |
| enum "te-bandwidth-pool1" { | | enum "te-bandwidth-pool1" { |
| description | | description |
| "Bandwidth pool type is pool1"; | | "Bandwidth pool type is pool1"; |
| } | | } |
| enum "te-bandwidth-any-pool" { | | enum "te-bandwidth-any-pool" { |
| description | | description |
| "Bandwidth pool type is any pool"; | | "Bandwidth pool type is any pool"; |
| } | | } |
| } | | } |
| description | | description |
| "Bandwidth pool type"; | | "Bandwidth pool type"; |
| } | | } |
| | | |
| typedef Hw-oor-state { | | typedef Hw-oor-state { |
| type enumeration { | | type enumeration { |
| enum "oor-green" { | | enum "oor-green" { |
| description | | description |
| "NPU resources are in normal state"; | | "NPU resources are in normal state"; |
| } | | } |
| enum "oor-yellow" { | | enum "oor-yellow" { |
| description | | description |
| "NPU resources are in minor state"; | | "NPU resources are in minor state"; |
| } | | } |
| enum "oor-red" { | | enum "oor-red" { |
| description | | description |
| "NPU resources are in Major state"; | | "NPU resources are in Major state"; |
| } | | } |
| } | | } |
| description | | description |
| "NPU resources states"; | | "NPU resources states"; |
| } | | } |
| | | |
| grouping MPLS-LM-SOFT-PREEMPTION-LINK-INFO { | | grouping MPLS-LM-SOFT-PREEMPTION-LINK-INFO { |
| description | | description |
| "Soft Preemption Info per Link"; | | "Soft Preemption Info per Link"; |
| leaf link-address { | | leaf link-address { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "The link's IPv4 address"; | | "The link's IPv4 address"; |
| } | | } |
| leaf total-soft-preempted-bandwidth-bc0 { | | leaf total-soft-preempted-bandwidth-bc0 { |
| type uint64; | | type uint64; |
| description | | description |
| "The total BC0 BW that is softly preempted: this | | "The total BC0 BW that is softly preempted: this |
| is the sum of bandwidth for all the LSPs that | | is the sum of bandwidth for all the LSPs that |
| were soft preempted"; | | were soft preempted"; |
| } | | } |
| leaf total-soft-preempted-bandwidth-bc1 { | | leaf total-soft-preempted-bandwidth-bc1 { |
| type uint64; | | type uint64; |
| description | | description |
| "The total BC1 BW that is softly preempted: this | | "The total BC1 BW that is softly preempted: this |
| is the sum of bandwidth for all the LSPs that | | is the sum of bandwidth for all the LSPs that |
| were soft preempted"; | | were soft preempted"; |
| } | | } |
| leaf current-soft-preempted-bandwidth-bc0 { | | leaf current-soft-preempted-bandwidth-bc0 { |
| type uint64; | | type uint64; |
| description | | description |
| "The current BC0 BW that is softly preempted: | | "The current BC0 BW that is softly preempted: |
| this is the sum of bandwidth for the LSPs that | | this is the sum of bandwidth for the LSPs that |
| are soft preempted and have not been torn down | | are soft preempted and have not been torn down |
| yet"; | | yet"; |
| } | | } |
| leaf current-soft-preempted-bandwidth-bc1 { | | leaf current-soft-preempted-bandwidth-bc1 { |
| type uint64; | | type uint64; |
| description | | description |
| "The current BC1 BW that is softly preempted: | | "The current BC1 BW that is softly preempted: |
| this is the sum of bandwidth for the LSPs that | | this is the sum of bandwidth for the LSPs that |
| are soft preempted and have not been torn down | | are soft preempted and have not been torn down |
| yet"; | | yet"; |
| } | | } |
| leaf release-soft-preempted-bandwidth-bc0 { | | leaf release-soft-preempted-bandwidth-bc0 { |
| type uint64; | | type uint64; |
| description | | description |
| "The total released BC0 BW that is softly | | "The total released BC0 BW that is softly |
| preempted: this is the sum of bandwidth for the | | preempted: this is the sum of bandwidth for the |
| LSPs that are soft preempted and are torn down"; | | LSPs that are soft preempted and are torn down"; |
| } | | } |
| leaf release-soft-preempted-bandwidth-bc1 { | | leaf release-soft-preempted-bandwidth-bc1 { |
| type uint64; | | type uint64; |
| description | | description |
| "The total released BC1 BW that is softly | | "The total released BC1 BW that is softly |
| preempted: this is the sum of bandwidth for the | | preempted: this is the sum of bandwidth for the |
| LSPs that are soft preempted and are torn down"; | | LSPs that are soft preempted and are torn down"; |
| } | | } |
| leaf current-over-subscribed-bandwidth-bc0 { | | leaf current-over-subscribed-bandwidth-bc0 { |
| type uint64; | | type uint64; |
| description | | description |
| "The BC0 bandwidth that is over subscribed on | | "The BC0 bandwidth that is over subscribed on |
| this link: this is the difference between the | | this link: this is the difference between the |
| maximum available BC0 BW on the link and the sum | | maximum available BC0 BW on the link and the sum |
| of the currently reserved BC0 bandwidth and the | | of the currently reserved BC0 bandwidth and the |
| currently soft preempted BC0 BW"; | | currently soft preempted BC0 BW"; |
| } | | } |
| leaf current-over-subscribed-bandwidth-bc1 { | | leaf current-over-subscribed-bandwidth-bc1 { |
| type uint64; | | type uint64; |
| description | | description |
| "The BC1 bandwidth that is over subscribed on | | "The BC1 bandwidth that is over subscribed on |
| this link: this is the difference between the | | this link: this is the difference between the |
| maximum available BC1 BW on the link and the sum | | maximum available BC1 BW on the link and the sum |
| of the currently reserved BC1 bandwidth and the | | of the currently reserved BC1 bandwidth and the |
| currently soft preempted BC1 BW"; | | currently soft preempted BC1 BW"; |
| } | | } |
| list current-soft-preemption-lsp { | | list current-soft-preemption-lsp { |
| description | | description |
| "List of the soft preempted LSPs that are not yet | | "List of the soft preempted LSPs that are not yet |
| cleaned up"; | | cleaned up"; |
| uses MPLS-LM-PREEMPTED-LSP; | | uses MPLS-LM-PREEMPTED-LSP; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-SOFT-PREEMPTION-GLOBAL-INFO { | | grouping MPLS-TE-SOFT-PREEMPTION-GLOBAL-INFO { |
| description | | description |
| "Global Soft Preemption Info"; | | "Global Soft Preemption Info"; |
| leaf is-configured { | | leaf is-configured { |
| type boolean; | | type boolean; |
| description | | description |
| "Is global soft-preemption configured"; | | "Is global soft-preemption configured"; |
| } | | } |
| leaf is-timeout-interval-configured { | | leaf is-timeout-interval-configured { |
| type boolean; | | type boolean; |
| description | | description |
| "Is global soft-preemption timeout interval | | "Is global soft-preemption timeout interval |
| configured"; | | configured"; |
| } | | } |
| leaf timeout-interval { | | leaf timeout-interval { |
| type uint32; | | type uint32; |
| description | | description |
| "Global soft-preemption timeout interval"; | | "Global soft-preemption timeout interval"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-LM-ADMISSION-CONTROL-TUNNEL-INFO { | | grouping MPLS-LM-ADMISSION-CONTROL-TUNNEL-INFO { |
| description | | description |
| "Information about a given admitted tunnel"; | | "Information about a given admitted tunnel"; |
| leaf tunnel-name { | | leaf tunnel-name { |
| type string; | | type string; |
| description | | description |
| "The admitted tunnel's name"; | | "The admitted tunnel's name"; |
| } | | } |
| leaf bandwidth-state { | | leaf bandwidth-state { |
| type Bandwidth-state-enum; | | type Bandwidth-state-enum; |
| description | | description |
| "The bandwidth state"; | | "The bandwidth state"; |
| } | | } |
| leaf bandwidth-pool { | | leaf bandwidth-pool { |
| type Bandwidth-type-enum; | | type Bandwidth-type-enum; |
| description | | description |
| "The bandwidth pool"; | | "The bandwidth pool"; |
| } | | } |
| leaf setup-priority { | | leaf setup-priority { |
| type uint8; | | type uint8; |
| description | | description |
| "The tunnel's setup priority"; | | "The tunnel's setup priority"; |
| } | | } |
| leaf hold-priority { | | leaf hold-priority { |
| type uint8; | | type uint8; |
| description | | description |
| "The tunnel's hold priority"; | | "The tunnel's hold priority"; |
| } | | } |
| leaf up-link-name { | | leaf up-link-name { |
| type string; | | type string; |
| description | | description |
| "The uplink's name for this tunnel"; | | "The uplink's name for this tunnel"; |
| } | | } |
| leaf down-link-name { | | leaf down-link-name { |
| type string; | | type string; |
| description | | description |
| "The downlink's name for this tunnel"; | | "The downlink's name for this tunnel"; |
| } | | } |
| leaf tunnel-state { | | leaf tunnel-state { |
| type Tunnel-state-enum; | | type Tunnel-state-enum; |
| description | | description |
| "The tunnel's state"; | | "The tunnel's state"; |
| } | | } |
| leaf bandwidth { | | leaf bandwidth { |
| type uint64; | | type uint64; |
| description | | description |
| "The bandwidth used by this tunnel"; | | "The bandwidth used by this tunnel"; |
| } | | } |
| leaf local-label { | | leaf local-label { |
| type uint32; | | type uint32; |
| description | | description |
| "The local label"; | | "The local label"; |
| } | | } |
| leaf outgoing-label { | | leaf outgoing-label { |
| type uint32; | | type uint32; |
| description | | description |
| "The outgoing label"; | | "The outgoing label"; |
| } | | } |
| leaf backup-interface { | | leaf backup-interface { |
| type string; | | type string; |
| description | | description |
| "The backup Interface"; | | "The backup Interface"; |
| } | | } |
| leaf is-rerouted { | | leaf is-rerouted { |
| type boolean; | | type boolean; |
| description | | description |
| "TRUE if the tunnel is currently rerouted"; | | "TRUE if the tunnel is currently rerouted"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-LM-ADMISSION-CONTROL-COMMON-INFO { | | grouping MPLS-LM-ADMISSION-CONTROL-COMMON-INFO { |
| description | | description |
| "Global information about admitted tunnels"; | | "Global information about admitted tunnels"; |
| leaf is-role-standby { | | leaf is-role-standby { |
| type boolean; | | type boolean; |
| description | | description |
| "TRUE if Role is Standby, Active otherwise"; | | "TRUE if Role is Standby, Active otherwise"; |
| } | | } |
| leaf total-tunnels { | | leaf total-tunnels { |
| type uint32; | | type uint32; |
| description | | description |
| "Total p2p tunnels admitted"; | | "Total p2p tunnels admitted"; |
| } | | } |
| leaf total-p2mp-tunnels { | | leaf total-p2mp-tunnels { |
| type uint32; | | type uint32; |
| description | | description |
| "Total p2mp tunnels admitted"; | | "Total p2mp tunnels admitted"; |
| } | | } |
| leaf selected-tunnels { | | leaf selected-tunnels { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of tunnels selected"; | | "Number of tunnels selected"; |
| } | | } |
| leaf bandwidth-units { | | leaf bandwidth-units { |
| type Bandwidth-unit-enum; | | type Bandwidth-unit-enum; |
| description | | description |
| "Bandwidth units"; | | "Bandwidth units"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-LM-INTERFACE-HW-OOR-INFO { | | grouping MPLS-LM-INTERFACE-HW-OOR-INFO { |
| description | | description |
| "Information about NPU Resources state for the | | "Information about NPU Resources state for the |
| link"; | | link"; |
| leaf hw-oor-state { | | leaf hw-oor-state { |
| type Hw-oor-state; | | type Hw-oor-state; |
| description | | description |
| "The NPU (Network Processor Unit) HW resource | | "The NPU (Network Processor Unit) HW resource |
| state"; | | state"; |
| } | | } |
| leaf hw-oor-timestamp { | | leaf hw-oor-timestamp { |
| type uint32; | | type uint32; |
| description | | description |
| "Timestamp when the OOR state last changed"; | | "Timestamp when the OOR state last changed"; |
| } | | } |
| leaf hw-o-or-green-recovery-time { | | leaf hw-o-or-green-recovery-time { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Time Remaining in Green Recovery State (seconds)"; | | "Time Remaining in Green Recovery State (seconds)"; |
| } | | } |
| list hw-o-or-link-statistic { | | list hw-o-or-link-statistic { |
| max-elements "3"; | | max-elements "3"; |
| description | | description |
| "HW OOR statistics for the link"; | | "HW OOR statistics for the link"; |
| uses TE-HW-OOR-STATS; | | uses TE-HW-OOR-STATS; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-LM-INTERFACE-LOCKOUT-INFO { | | grouping MPLS-LM-INTERFACE-LOCKOUT-INFO { |
| description | | description |
| "Information about flex LSP lockout info for the | | "Information about flex LSP lockout info for the |
| link"; | | link"; |
| leaf is-lockout { | | leaf is-lockout { |
| type boolean; | | type boolean; |
| description | | description |
| "True if link is locked out"; | | "True if link is locked out"; |
| } | | } |
| leaf lockout-on-timestamp { | | leaf lockout-on-timestamp { |
| type uint32; | | type uint32; |
| description | | description |
| "Timestamp when the lockout is set"; | | "Timestamp when the lockout is set"; |
| } | | } |
| leaf lockout-off-timestamp { | | leaf lockout-off-timestamp { |
| type uint32; | | type uint32; |
| description | | description |
| "Timestamp when the lockout is cleared"; | | "Timestamp when the lockout is cleared"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-LM-INTERFACE-LINK-AREA-INFO { | | grouping MPLS-LM-INTERFACE-LINK-AREA-INFO { |
| description | | description |
| "Information about an area to which the link | | "Information about an area to which the link |
| belongs"; | | belongs"; |
| leaf area-id { | | leaf area-id { |
| type string; | | type string; |
| description | | description |
| "Area id"; | | "Area id"; |
| } | | } |
| leaf neighbor-id { | | leaf neighbor-id { |
| type string; | | type string; |
| description | | description |
| "The interface neighbor id"; | | "The interface neighbor id"; |
| } | | } |
| leaf neighbor-address { | | leaf neighbor-address { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "The interface's neighbor's ip address"; | | "The interface's neighbor's ip address"; |
| } | | } |
| leaf is-neighbor-up { | | leaf is-neighbor-up { |
| type boolean; | | type boolean; |
| description | | description |
| "TRUE if the neighbor is up"; | | "TRUE if the neighbor is up"; |
| } | | } |
| leaf igp-metric { | | leaf igp-metric { |
| type uint32; | | type uint32; |
| description | | description |
| "The link's IGP metric"; | | "The link's IGP metric"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-DARKBW-SAMPLE-SR { | | grouping MPLS-TE-DARKBW-SAMPLE-SR { |
| description | | description |
| "Information about a single Segment Routing | | "Information about a single Segment Routing |
| bandwidth accounting sample"; | | bandwidth accounting sample"; |
| leaf timestamp { | | leaf timestamp { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Timestamp in seconds of this sample"; | | "Timestamp in seconds of this sample"; |
| } | | } |
| leaf sr-rate { | | leaf sr-rate { |
| type uint64; | | type uint64; |
| units "kbit/s"; | | units "kbit/s"; |
| description | | description |
| "Segment Routing traffic rate measured in | | "Segment Routing traffic rate measured in |
| Kilobits per second in this sample"; | | Kilobits per second in this sample"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-DARKBW-HISTORY-SR { | | grouping MPLS-TE-DARKBW-HISTORY-SR { |
| description | | description |
| "Segment Routing Bandwidth accounting history"; | | "Segment Routing Bandwidth accounting history"; |
| list sr-active-interval-sample { | | list sr-active-interval-sample { |
| description | | description |
| "Segment Routing samples in the current | | "Segment Routing samples in the current |
| application interval"; | | application interval"; |
| uses MPLS-TE-DARKBW-SAMPLE-SR; | | uses MPLS-TE-DARKBW-SAMPLE-SR; |
| } | | } |
| list sr-previous-interval-sample { | | list sr-previous-interval-sample { |
| description | | description |
| "Segment Routing samples in the previous | | "Segment Routing samples in the previous |
| application interval"; | | application interval"; |
| uses MPLS-TE-DARKBW-SAMPLE-SR; | | uses MPLS-TE-DARKBW-SAMPLE-SR; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-DARKBW-SAMPLE-RSVP { | | grouping MPLS-TE-DARKBW-SAMPLE-RSVP { |
| description | | description |
| "Information about a single RSVP-TE bandwidth | | "Information about a single RSVP-TE bandwidth |
| accounting sample"; | | accounting sample"; |
| leaf timestamp { | | leaf timestamp { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Timestamp in seconds of this sample"; | | "Timestamp in seconds of this sample"; |
| } | | } |
| leaf total-rate { | | leaf total-rate { |
| type uint64; | | type uint64; |
| units "kbit/s"; | | units "kbit/s"; |
| description | | description |
| "Total traffic rate measured in Kilobits per | | "Total traffic rate measured in Kilobits per |
| second in this sample"; | | second in this sample"; |
| } | | } |
| leaf rsvp-te-rate { | | leaf rsvp-te-rate { |
| type uint64; | | type uint64; |
| units "kbit/s"; | | units "kbit/s"; |
| description | | description |
| "RSVP-TE traffic rate measured in Kilobits per | | "RSVP-TE traffic rate measured in Kilobits per |
| second in this sample"; | | second in this sample"; |
| } | | } |
| leaf non-rsvp-te-rate { | | leaf non-rsvp-te-rate { |
| type uint64; | | type uint64; |
| units "kbit/s"; | | units "kbit/s"; |
| description | | description |
| "Non-RSVP-TE traffic rate measured in Kilobits | | "Non-RSVP-TE traffic rate measured in Kilobits |
| per second in this sample"; | | per second in this sample"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-DARKBW-HISTORY-RSVP { | | grouping MPLS-TE-DARKBW-HISTORY-RSVP { |
| description | | description |
| "RSVP-TE Bandwidth accounting history"; | | "RSVP-TE Bandwidth accounting history"; |
| list rsvp-te-active-interval-sample { | | list rsvp-te-active-interval-sample { |
| description | | description |
| "RSVP-TE samples in the current application | | "RSVP-TE samples in the current application |
| interval"; | | interval"; |
| uses MPLS-TE-DARKBW-SAMPLE-RSVP; | | uses MPLS-TE-DARKBW-SAMPLE-RSVP; |
| } | | } |
| list rsvp-te-previous-interval-sample { | | list rsvp-te-previous-interval-sample { |
| description | | description |
| "RSVP-TE samples in the previous application | | "RSVP-TE samples in the previous application |
| interval"; | | interval"; |
| uses MPLS-TE-DARKBW-SAMPLE-RSVP; | | uses MPLS-TE-DARKBW-SAMPLE-RSVP; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-DARKBW-BW-UTIL-SR { | | grouping MPLS-TE-DARKBW-BW-UTIL-SR { |
| description | | description |
| "Information about Segment Routing bandwidth | | "Information about Segment Routing bandwidth |
| utilization in bandwidth accounting"; | | utilization in bandwidth accounting"; |
| leaf sr-bandwidth-utilization { | | leaf sr-bandwidth-utilization { |
| type uint64; | | type uint64; |
| units "kbit/s"; | | units "kbit/s"; |
| description | | description |
| "Segment Routing bandwidth utilization measured | | "Segment Routing bandwidth utilization measured |
| in kilobits per second"; | | in kilobits per second"; |
| } | | } |
| leaf sr-adjusted-bandwidth-utilization { | | leaf sr-adjusted-bandwidth-utilization { |
| type uint64; | | type uint64; |
| units "kbit/s"; | | units "kbit/s"; |
| description | | description |
| "Adjusted Segment Routing bandwidth utilization | | "Adjusted Segment Routing bandwidth utilization |
| measured in kilobits per second"; | | measured in kilobits per second"; |
| } | | } |
| leaf sr-enforced-bandwidth-utilization { | | leaf sr-enforced-bandwidth-utilization { |
| type uint64; | | type uint64; |
| units "kbit/s"; | | units "kbit/s"; |
| description | | description |
| "Enforced Segment Routing bandwidth utilization | | "Enforced Segment Routing bandwidth utilization |
| measured in kilobits per second"; | | measured in kilobits per second"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-DARKBW-BW-UTIL-RSVP { | | grouping MPLS-TE-DARKBW-BW-UTIL-RSVP { |
| description | | description |
| "Information about RSVP-TE bandwidth utilization | | "Information about RSVP-TE bandwidth utilization |
| in bandwidth accounting"; | | in bandwidth accounting"; |
| leaf total-link-bandwidth-utilization { | | leaf total-link-bandwidth-utilization { |
| type uint64; | | type uint64; |
| units "kbit/s"; | | units "kbit/s"; |
| description | | description |
| "Total bandwidth utilization measured in kilobits | | "Total bandwidth utilization measured in kilobits |
| per second"; | | per second"; |
| } | | } |
| leaf rsvp-te-bandwidth-utilization { | | leaf rsvp-te-bandwidth-utilization { |
| type uint64; | | type uint64; |
| units "kbit/s"; | | units "kbit/s"; |
| description | | description |
| "RSVP-TE bandwidth utilization measured in | | "RSVP-TE bandwidth utilization measured in |
| kilobits per second"; | | kilobits per second"; |
| } | | } |
| leaf non-rsvp-te-bandwidth-utilization { | | leaf non-rsvp-te-bandwidth-utilization { |
| type uint64; | | type uint64; |
| units "kbit/s"; | | units "kbit/s"; |
| description | | description |
| "Non-RSVP-TE bandwidth utilization measured in | | "Non-RSVP-TE bandwidth utilization measured in |
| kilobits per second"; | | kilobits per second"; |
| } | | } |
| leaf rsvp-te-adjusted-bandwidth-utilization { | | leaf rsvp-te-adjusted-bandwidth-utilization { |
| type uint64; | | type uint64; |
| units "kbit/s"; | | units "kbit/s"; |
| description | | description |
| "Adjusted RSVP-TE bandwidth utilization measured | | "Adjusted RSVP-TE bandwidth utilization measured |
| in kilobits per second"; | | in kilobits per second"; |
| } | | } |
| leaf rsvp-te-enforced-bandwidth-utilization { | | leaf rsvp-te-enforced-bandwidth-utilization { |
| type uint64; | | type uint64; |
| units "kbit/s"; | | units "kbit/s"; |
| description | | description |
| "Enforced RSVP-TE bandwidth utilization measured | | "Enforced RSVP-TE bandwidth utilization measured |
| in kilobits per second"; | | in kilobits per second"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-LM-DARKBW-LINK-COMMON-INFO { | | grouping MPLS-LM-DARKBW-LINK-COMMON-INFO { |
| description | | description |
| "Information for bandwidth accounting per link"; | | "Information for bandwidth accounting per link"; |
| container rsvp-te-bandwidth-utilization { | | container rsvp-te-bandwidth-utilization { |
| description | | description |
| "RSVP-TE Bandwidth utilization information"; | | "RSVP-TE Bandwidth utilization information"; |
| uses MPLS-TE-DARKBW-BW-UTIL-RSVP; | | uses MPLS-TE-DARKBW-BW-UTIL-RSVP; |
| } | | } |
| container sr-bandwidth-utilization { | | container sr-bandwidth-utilization { |
| description | | description |
| "Segment Routing Bandwidth utilization | | "Segment Routing Bandwidth utilization |
| information"; | | information"; |
| uses MPLS-TE-DARKBW-BW-UTIL-SR; | | uses MPLS-TE-DARKBW-BW-UTIL-SR; |
| } | | } |
| leaf is-bandwidth-account-enabled { | | leaf is-bandwidth-account-enabled { |
| type boolean; | | type boolean; |
| description | | description |
| "TRUE if bandwidth accounting is enabled"; | | "TRUE if bandwidth accounting is enabled"; |
| } | | } |
| leaf application-enforced { | | leaf application-enforced { |
| type boolean; | | type boolean; |
| description | | description |
| "TRUE if bandwidth accounting application is | | "TRUE if bandwidth accounting application is |
| enforced"; | | enforced"; |
| } | | } |
| leaf collection-type { | | leaf collection-type { |
| type Bandwidth-accounting-collection; | | type Bandwidth-accounting-collection; |
| description | | description |
| "The type of traffic collected for bandwidth | | "The type of traffic collected for bandwidth |
| accounting"; | | accounting"; |
| } | | } |
| leaf sample-interval { | | leaf sample-interval { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Sampling interval in seconds for bandwidth | | "Sampling interval in seconds for bandwidth |
| accounting stats"; | | accounting stats"; |
| } | | } |
| leaf sample-time-remaining { | | leaf sample-time-remaining { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "This value indicates the number of seconds until | | "This value indicates the number of seconds until |
| the next sampling"; | | the next sampling"; |
| } | | } |
| leaf last-sample-collection-timestamp { | | leaf last-sample-collection-timestamp { |
| type uint32; | | type uint32; |
| description | | description |
| "Timestamp for the last sample collection"; | | "Timestamp for the last sample collection"; |
| } | | } |
| leaf next-sample-collection { | | leaf next-sample-collection { |
| type uint32; | | type uint32; |
| description | | description |
| "Timestamp for the next sample collection"; | | "Timestamp for the next sample collection"; |
| } | | } |
| leaf application-interval { | | leaf application-interval { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Application interval in seconds for bandwidth | | "Application interval in seconds for bandwidth |
| accounting stats"; | | accounting stats"; |
| } | | } |
| leaf application-time-remaining { | | leaf application-time-remaining { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "This value indicates the number of seconds until | | "This value indicates the number of seconds until |
| the next application"; | | the next application"; |
| } | | } |
| leaf last-application-timestamp { | | leaf last-application-timestamp { |
| type uint32; | | type uint32; |
| description | | description |
| "Timestamp for the last application"; | | "Timestamp for the last application"; |
| } | | } |
| leaf next-application { | | leaf next-application { |
| type uint32; | | type uint32; |
| description | | description |
| "Timestamp for the next application"; | | "Timestamp for the next application"; |
| } | | } |
| leaf adjustment-factor { | | leaf adjustment-factor { |
| type uint32; | | type uint32; |
| description | | description |
| "This value indicates the adjustment factor | | "This value indicates the adjustment factor |
| applied to measured non RSVP-TE bandwidth"; | | applied to measured non RSVP-TE bandwidth"; |
| } | | } |
| leaf max-reservable-bandwidth-threshold-are-default { | | leaf max-reservable-bandwidth-threshold-are-default { |
| type boolean; | | type boolean; |
| description | | description |
| "TRUE if the maximum reservable bandwidth | | "TRUE if the maximum reservable bandwidth |
| flooding thresholds are default"; | | flooding thresholds are default"; |
| } | | } |
| leaf up-threshold-max-reservable-bandwidth { | | leaf up-threshold-max-reservable-bandwidth { |
| type uint8; | | type uint8; |
| description | | description |
| "The up threshold for flooding the maximum | | "The up threshold for flooding the maximum |
| reservable bandwidth"; | | reservable bandwidth"; |
| } | | } |
| leaf down-threshold-max-reservable-bandwidth { | | leaf down-threshold-max-reservable-bandwidth { |
| type uint8; | | type uint8; |
| description | | description |
| "The down threshold for flooding the maximum | | "The down threshold for flooding the maximum |
| reservable bandwidth"; | | reservable bandwidth"; |
| } | | } |
| n | leaf flooding-trigger-type { | n | |
| type Bandwidth-accounting-flooding-trigger; | | |
| description | | |
| "The type of flooding triggers for bandwidth | | |
| accounting"; | | |
| } | | |
| leaf sr-traffic-percentage { | | |
| type uint8; | | |
| units "percentage"; | | |
| description | | |
| "The percentage of segment-routing traffic as | | |
| threshold for flooding"; | | |
| } | | |
| } | | } |
| | | |
| grouping MPLS-LM-DARKBW-LINK-INFO { | | grouping MPLS-LM-DARKBW-LINK-INFO { |
| description | | description |
| "Detail information for bandwidth accounting per | | "Detail information for bandwidth accounting per |
| link"; | | link"; |
| container bandwidth-account-common-info { | | container bandwidth-account-common-info { |
| description | | description |
| "Common info for bandwidth accounting"; | | "Common info for bandwidth accounting"; |
| uses MPLS-LM-DARKBW-LINK-COMMON-INFO; | | uses MPLS-LM-DARKBW-LINK-COMMON-INFO; |
| } | | } |
| container rsvp-te-bandwidth-sample-history { | | container rsvp-te-bandwidth-sample-history { |
| description | | description |
| "RSVP-TE Bandwidth samples history"; | | "RSVP-TE Bandwidth samples history"; |
| uses MPLS-TE-DARKBW-HISTORY-RSVP; | | uses MPLS-TE-DARKBW-HISTORY-RSVP; |
| } | | } |
| container sr-bandwidth-sample-history { | | container sr-bandwidth-sample-history { |
| description | | description |
| "Segment Routing Bandwidth samples history"; | | "Segment Routing Bandwidth samples history"; |
| uses MPLS-TE-DARKBW-HISTORY-SR; | | uses MPLS-TE-DARKBW-HISTORY-SR; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-LM-INTERFACE-LINK-INFO { | | grouping MPLS-LM-INTERFACE-LINK-INFO { |
| description | | description |
| "IGP and area information of a link"; | | "IGP and area information of a link"; |
| container link-common { | | container link-common { |
| description | | description |
| "The link's common info"; | | "The link's common info"; |
| uses MPLS-LM-COMMON-LINK-INFO; | | uses MPLS-LM-COMMON-LINK-INFO; |
| } | | } |
| container bandwidth-account { | | container bandwidth-account { |
| description | | description |
| "Bandwidth Account info"; | | "Bandwidth Account info"; |
| uses MPLS-LM-DARKBW-LINK-INFO; | | uses MPLS-LM-DARKBW-LINK-INFO; |
| } | | } |
| container hw-oor { | | container hw-oor { |
| description | | description |
| "The link's NPU OOR info. This field is NULL for | | "The link's NPU OOR info. This field is NULL for |
| platforms that do not support HW-OOR | | platforms that do not support HW-OOR |
| notifications"; | | notifications"; |
| uses MPLS-LM-INTERFACE-HW-OOR-INFO; | | uses MPLS-LM-INTERFACE-HW-OOR-INFO; |
| } | | } |
| leaf reason-not-flooded { | | leaf reason-not-flooded { |
| type string; | | type string; |
| description | | description |
| "Reason why link is not flooded | | "Reason why link is not flooded |
| (area-independent)"; | | (area-independent)"; |
| } | | } |
| leaf maximum-reservation-bandwidth-rdm { | | leaf maximum-reservation-bandwidth-rdm { |
| type uint64; | | type uint64; |
| description | | description |
| "The link's maximum reservable BW in RDM"; | | "The link's maximum reservable BW in RDM"; |
| } | | } |
| leaf reservable-pool0-bandwidth-rdm { | | leaf reservable-pool0-bandwidth-rdm { |
| type uint64; | | type uint64; |
| description | | description |
| "The link's reservable pool0 BW in RDM"; | | "The link's reservable pool0 BW in RDM"; |
| } | | } |
| leaf reservable-pool1-bandwidth-rdm { | | leaf reservable-pool1-bandwidth-rdm { |
| type uint64; | | type uint64; |
| description | | description |
| "The link's reservable pool1 BW in RDM"; | | "The link's reservable pool1 BW in RDM"; |
| } | | } |
| leaf maximum-reservation-bandwidth-mam { | | leaf maximum-reservation-bandwidth-mam { |
| type uint64; | | type uint64; |
| description | | description |
| "The link's maximum reservable BW in MAM"; | | "The link's maximum reservable BW in MAM"; |
| } | | } |
| leaf reservable-pool0-bandwidth-mam { | | leaf reservable-pool0-bandwidth-mam { |
| type uint64; | | type uint64; |
| description | | description |
| "The link's reservable pool0 BW in MAM"; | | "The link's reservable pool0 BW in MAM"; |
| } | | } |
| leaf reservable-pool1-bandwidth-mam { | | leaf reservable-pool1-bandwidth-mam { |
| type uint64; | | type uint64; |
| description | | description |
| "The link's reservable pool1 BW in MAM"; | | "The link's reservable pool1 BW in MAM"; |
| } | | } |
| leaf link-attributes { | | leaf link-attributes { |
| type uint32; | | type uint32; |
| description | | description |
| "Deprecated"; | | "Deprecated"; |
| } | | } |
| leaf is-attribute-incomplete { | | leaf is-attribute-incomplete { |
| type boolean; | | type boolean; |
| description | | description |
| "TRUE if one or more affinity definition(s) | | "TRUE if one or more affinity definition(s) |
| is/are unknown"; | | is/are unknown"; |
| } | | } |
| leaf is-name-based-attribute { | | leaf is-name-based-attribute { |
| type boolean; | | type boolean; |
| description | | description |
| "TRUE, if name based attribute style is in effect"; | | "TRUE, if name based attribute style is in effect"; |
| } | | } |
| leaf te-metric { | | leaf te-metric { |
| type uint32; | | type uint32; |
| description | | description |
| "The link's TE metric"; | | "The link's TE metric"; |
| } | | } |
| leaf is-te-metric-valid { | | leaf is-te-metric-valid { |
| type boolean; | | type boolean; |
| description | | description |
| "Flag to indicate whether the link's TE metric is | | "Flag to indicate whether the link's TE metric is |
| a valid value"; | | a valid value"; |
| } | | } |
| list link-extended-attribute { | | list link-extended-attribute { |
| description | | description |
| "The link's extended attribute bit map"; | | "The link's extended attribute bit map"; |
| leaf entry { | | leaf entry { |
| type uint32; | | type uint32; |
| description | | description |
| "The link's extended attribute bit map"; | | "The link's extended attribute bit map"; |
| } | | } |
| } | | } |
| list link-forwad-ref-value { | | list link-forwad-ref-value { |
| description | | description |
| "Reference bits for undefined affinity names"; | | "Reference bits for undefined affinity names"; |
| leaf entry { | | leaf entry { |
| type uint32; | | type uint32; |
| description | | description |
| "Reference bits for undefined affinity names"; | | "Reference bits for undefined affinity names"; |
| } | | } |
| } | | } |
| list affinity-map { | | list affinity-map { |
| description | | description |
| "Affinity map array"; | | "Affinity map array"; |
| uses MPLS-TE-AFFINITY-MAP-INFO; | | uses MPLS-TE-AFFINITY-MAP-INFO; |
| } | | } |
| list areas { | | list areas { |
| description | | description |
| "Per-area data"; | | "Per-area data"; |
| uses MPLS-LM-INTERFACE-LINK-AREA-INFO; | | uses MPLS-LM-INTERFACE-LINK-AREA-INFO; |
| } | | } |
| list lockout { | | list lockout { |
| description | | description |
| "Flex LSP Lockout info"; | | "Flex LSP Lockout info"; |
| uses MPLS-LM-INTERFACE-LOCKOUT-INFO; | | uses MPLS-LM-INTERFACE-LOCKOUT-INFO; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-LM-INTERFACE-COMMON-INFO { | | grouping MPLS-LM-INTERFACE-COMMON-INFO { |
| description | | description |
| "Global info about links"; | | "Global info about links"; |
| leaf is-role-standby { | | leaf is-role-standby { |
| type boolean; | | type boolean; |
| description | | description |
| "TRUE if Role is Standby, Active otherwise"; | | "TRUE if Role is Standby, Active otherwise"; |
| } | | } |
| leaf links { | | leaf links { |
| type uint16; | | type uint16; |
| description | | description |
| "The number of links"; | | "The number of links"; |
| } | | } |
| leaf maximum-links { | | leaf maximum-links { |
| type uint16; | | type uint16; |
| description | | description |
| "Maximum number of links supported"; | | "Maximum number of links supported"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-LM-SUMMARY-DARKBW { | | grouping MPLS-LM-SUMMARY-DARKBW { |
| description | | description |
| "Summary information for bandwidth accounting"; | | "Summary information for bandwidth accounting"; |
| leaf is-bandwidth-account-enabled { | | leaf is-bandwidth-account-enabled { |
| type boolean; | | type boolean; |
| description | | description |
| "TRUE if bandwidth accounting is enabled"; | | "TRUE if bandwidth accounting is enabled"; |
| } | | } |
| leaf sample-interval { | | leaf sample-interval { |
| type uint32; | | type uint32; |
| description | | description |
| "Sample interval for bandwidth accounting stats"; | | "Sample interval for bandwidth accounting stats"; |
| } | | } |
| leaf sample-time-remaining { | | leaf sample-time-remaining { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "This value indicates the number of seconds until | | "This value indicates the number of seconds until |
| the next sample collection"; | | the next sample collection"; |
| } | | } |
| leaf application-interval { | | leaf application-interval { |
| type uint32; | | type uint32; |
| description | | description |
| "Application interval for bandwidth accounting | | "Application interval for bandwidth accounting |
| stats"; | | stats"; |
| } | | } |
| leaf application-time-remaining { | | leaf application-time-remaining { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "This value indicates the number of seconds until | | "This value indicates the number of seconds until |
| the next application"; | | the next application"; |
| } | | } |
| leaf links-count { | | leaf links-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of links"; | | "Total number of links"; |
| } | | } |
| leaf maximum-links { | | leaf maximum-links { |
| type uint32; | | type uint32; |
| description | | description |
| "Maximum number of links supported"; | | "Maximum number of links supported"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-LM-SUMMARY-AREA-INFO { | | grouping MPLS-LM-SUMMARY-AREA-INFO { |
| description | | description |
| "Summary information of an area"; | | "Summary information of an area"; |
| leaf area-id { | | leaf area-id { |
| type string; | | type string; |
| description | | description |
| "Area id"; | | "Area id"; |
| } | | } |
| leaf protocol { | | leaf protocol { |
| type Igp-protocol; | | type Igp-protocol; |
| description | | description |
| "Protocol running over the area"; | | "Protocol running over the area"; |
| } | | } |
| leaf is-flooded { | | leaf is-flooded { |
| type boolean; | | type boolean; |
| description | | description |
| "TRUE if flooding occurred in this area"; | | "TRUE if flooding occurred in this area"; |
| } | | } |
| leaf is-periodic-flooding-on { | | leaf is-periodic-flooding-on { |
| type boolean; | | type boolean; |
| description | | description |
| "TRUE if periodic flooding is on"; | | "TRUE if periodic flooding is on"; |
| } | | } |
| leaf periodic-flooding-interval { | | leaf periodic-flooding-interval { |
| type uint16; | | type uint16; |
| units "second"; | | units "second"; |
| description | | description |
| "Flooding period in seconds"; | | "Flooding period in seconds"; |
| } | | } |
| leaf links-flooded { | | leaf links-flooded { |
| type uint16; | | type uint16; |
| description | | description |
| "Number of flooded links"; | | "Number of flooded links"; |
| } | | } |
| leaf system-id { | | leaf system-id { |
| type string; | | type string; |
| description | | description |
| "IGP id of local node"; | | "IGP id of local node"; |
| } | | } |
| leaf local-node-router-id { | | leaf local-node-router-id { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Local router id"; | | "Local router id"; |
| } | | } |
| leaf igp-neighbors { | | leaf igp-neighbors { |
| type uint16; | | type uint16; |
| description | | description |
| "Number of IGP neighbors"; | | "Number of IGP neighbors"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-LM-SUMMARY-COMMON-INFO { | | grouping MPLS-LM-SUMMARY-COMMON-INFO { |
| description | | description |
| "Summary information for all the areas"; | | "Summary information for all the areas"; |
| container bandwidth-account-summary { | | container bandwidth-account-summary { |
| description | | description |
| "Bandwidth account summary"; | | "Bandwidth account summary"; |
| uses MPLS-LM-SUMMARY-DARKBW; | | uses MPLS-LM-SUMMARY-DARKBW; |
| } | | } |
| leaf is-role-standby { | | leaf is-role-standby { |
| type boolean; | | type boolean; |
| description | | description |
| "TRUE if Role is Standby, Active otherwise"; | | "TRUE if Role is Standby, Active otherwise"; |
| } | | } |
| leaf links { | | leaf links { |
| type uint16; | | type uint16; |
| description | | description |
| "Total number of links"; | | "Total number of links"; |
| } | | } |
| leaf maximum-links { | | leaf maximum-links { |
| type uint16; | | type uint16; |
| description | | description |
| "Maximum number of links supported"; | | "Maximum number of links supported"; |
| } | | } |
| leaf is-flooding-enabled { | | leaf is-flooding-enabled { |
| type boolean; | | type boolean; |
| description | | description |
| "TRUE if flooding is enabled"; | | "TRUE if flooding is enabled"; |
| n | } | n | |
| list flood-trigger-stat { | | |
| max-elements "26"; | | |
| description | | |
| "Stats for the flooding triggeres"; | | |
| leaf entry { | | |
| type uint32; | | |
| description | | |
| "Stats for the flooding triggeres"; | | |
| } | | |
| } | | } |
| list areas-summary { | | list areas-summary { |
| description | | description |
| "Summary info for the areas"; | | "Summary info for the areas"; |
| uses MPLS-LM-SUMMARY-AREA-INFO; | | uses MPLS-LM-SUMMARY-AREA-INFO; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-BANDWIDTH-ACCOUNT-SAMPLE-SR { | | grouping MPLS-TE-BANDWIDTH-ACCOUNT-SAMPLE-SR { |
| description | | description |
| "Information about a single Segment Routing | | "Information about a single Segment Routing |
| bandwidth accounting sample"; | | bandwidth accounting sample"; |
| leaf timestamp-nanosec { | | leaf timestamp-nanosec { |
| type uint64; | | type uint64; |
| units "nanosecond"; | | units "nanosecond"; |
| description | | description |
| "Timestamp in nano-seconds of this sample"; | | "Timestamp in nano-seconds of this sample"; |
| } | | } |
| leaf sr-rate { | | leaf sr-rate { |
| type uint64; | | type uint64; |
| units "kbit/s"; | | units "kbit/s"; |
| description | | description |
| "Segment Routing traffic rate measured in | | "Segment Routing traffic rate measured in |
| Kilobits per second in this sample"; | | Kilobits per second in this sample"; |
| } | | } |
| leaf sr-packet-rate { | | leaf sr-packet-rate { |
| type uint64; | | type uint64; |
| units "packet/s"; | | units "packet/s"; |
| description | | description |
| "Segment Routing traffic rate measured in packets | | "Segment Routing traffic rate measured in packets |
| per second in this sample"; | | per second in this sample"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-BANDWIDTH-ACCOUNT-HISTORY-SR { | | grouping MPLS-TE-BANDWIDTH-ACCOUNT-HISTORY-SR { |
| description | | description |
| "Segment Routing bandwidth account history"; | | "Segment Routing bandwidth account history"; |
| list sr-active-interval-sample { | | list sr-active-interval-sample { |
| description | | description |
| "Segment Routing samples in the current | | "Segment Routing samples in the current |
| application interval"; | | application interval"; |
| uses MPLS-TE-BANDWIDTH-ACCOUNT-SAMPLE-SR; | | uses MPLS-TE-BANDWIDTH-ACCOUNT-SAMPLE-SR; |
| } | | } |
| list sr-previous-interval-sample { | | list sr-previous-interval-sample { |
| description | | description |
| "Segment Routing samples in the previous | | "Segment Routing samples in the previous |
| application interval"; | | application interval"; |
| uses MPLS-TE-BANDWIDTH-ACCOUNT-SAMPLE-SR; | | uses MPLS-TE-BANDWIDTH-ACCOUNT-SAMPLE-SR; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-BANDWIDTH-ACCOUNT-SAMPLE-RSVP { | | grouping MPLS-TE-BANDWIDTH-ACCOUNT-SAMPLE-RSVP { |
| description | | description |
| "Information about a single RSVP-TE bandwidth | | "Information about a single RSVP-TE bandwidth |
| accounting sample"; | | accounting sample"; |
| leaf timestamp-nanosec { | | leaf timestamp-nanosec { |
| type uint64; | | type uint64; |
| units "nanosecond"; | | units "nanosecond"; |
| description | | description |
| "Timestamp in nano-seconds of this sample"; | | "Timestamp in nano-seconds of this sample"; |
| } | | } |
| leaf total-rate { | | leaf total-rate { |
| type uint64; | | type uint64; |
| units "kbit/s"; | | units "kbit/s"; |
| description | | description |
| "Total traffic rate measured in Kilobits per | | "Total traffic rate measured in Kilobits per |
| second in this sample"; | | second in this sample"; |
| } | | } |
| leaf total-packet-rate { | | leaf total-packet-rate { |
| type uint64; | | type uint64; |
| units "packet/s"; | | units "packet/s"; |
| description | | description |
| "Total traffic rate measured in packets per | | "Total traffic rate measured in packets per |
| second in this sample"; | | second in this sample"; |
| } | | } |
| leaf rsvp-te-rate { | | leaf rsvp-te-rate { |
| type uint64; | | type uint64; |
| units "kbit/s"; | | units "kbit/s"; |
| description | | description |
| "RSVP-TE traffic rate measured in Kilobits per | | "RSVP-TE traffic rate measured in Kilobits per |
| second in this sample"; | | second in this sample"; |
| } | | } |
| leaf rsvp-te-packet-rate { | | leaf rsvp-te-packet-rate { |
| type uint64; | | type uint64; |
| units "packet/s"; | | units "packet/s"; |
| description | | description |
| "RSVP-TE traffic rate measured in packets per | | "RSVP-TE traffic rate measured in packets per |
| second in this sample"; | | second in this sample"; |
| } | | } |
| leaf non-rsvp-te-rate { | | leaf non-rsvp-te-rate { |
| type uint64; | | type uint64; |
| units "kbit/s"; | | units "kbit/s"; |
| description | | description |
| "Non-RSVP-TE traffic rate measured in Kilobits | | "Non-RSVP-TE traffic rate measured in Kilobits |
| per second in this sample"; | | per second in this sample"; |
| } | | } |
| leaf non-rsvp-te-packet-rate { | | leaf non-rsvp-te-packet-rate { |
| type uint64; | | type uint64; |
| units "packet/s"; | | units "packet/s"; |
| description | | description |
| "Non-RSVP-TE traffic rate measured in packets per | | "Non-RSVP-TE traffic rate measured in packets per |
| second in this sample"; | | second in this sample"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-BANDWIDTH-ACCOUNT-HISTORY-RSVP { | | grouping MPLS-TE-BANDWIDTH-ACCOUNT-HISTORY-RSVP { |
| description | | description |
| "RSVP-TE bandwidth account history"; | | "RSVP-TE bandwidth account history"; |
| list rsvp-te-active-interval-sample { | | list rsvp-te-active-interval-sample { |
| description | | description |
| "RSVP-TE samples in the current application | | "RSVP-TE samples in the current application |
| interval"; | | interval"; |
| uses MPLS-TE-BANDWIDTH-ACCOUNT-SAMPLE-RSVP; | | uses MPLS-TE-BANDWIDTH-ACCOUNT-SAMPLE-RSVP; |
| } | | } |
| list rsvp-te-previous-interval-sample { | | list rsvp-te-previous-interval-sample { |
| description | | description |
| "RSVP-TE samples in the previous application | | "RSVP-TE samples in the previous application |
| interval"; | | interval"; |
| uses MPLS-TE-BANDWIDTH-ACCOUNT-SAMPLE-RSVP; | | uses MPLS-TE-BANDWIDTH-ACCOUNT-SAMPLE-RSVP; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-BANDWIDTH-ACCOUNT-BW-UTIL-SR { | | grouping MPLS-TE-BANDWIDTH-ACCOUNT-BW-UTIL-SR { |
| description | | description |
| "Information about Segment Routing bandwidth | | "Information about Segment Routing bandwidth |
| utilization in bandwidth accounting"; | | utilization in bandwidth accounting"; |
| leaf sr-bandwidth-utilization { | | leaf sr-bandwidth-utilization { |
| type uint64; | | type uint64; |
| units "kbit/s"; | | units "kbit/s"; |
| description | | description |
| "Segment Routing bandwidth utilization measured | | "Segment Routing bandwidth utilization measured |
| in kilobits per second"; | | in kilobits per second"; |
| } | | } |
| leaf sr-adjusted-bandwidth-utilization { | | leaf sr-adjusted-bandwidth-utilization { |
| type uint64; | | type uint64; |
| units "kbit/s"; | | units "kbit/s"; |
| description | | description |
| "Adjusted Segment Routing bandwidth utilization | | "Adjusted Segment Routing bandwidth utilization |
| measured in kilobits per second"; | | measured in kilobits per second"; |
| } | | } |
| leaf sr-enforced-bandwidth-utilization { | | leaf sr-enforced-bandwidth-utilization { |
| type uint64; | | type uint64; |
| units "kbit/s"; | | units "kbit/s"; |
| description | | description |
| "Enforced Segment Routing bandwidth utilization | | "Enforced Segment Routing bandwidth utilization |
| measured in kilobits per second"; | | measured in kilobits per second"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-BANDWIDTH-ACCOUNT-BW-UTIL-RSVP { | | grouping MPLS-TE-BANDWIDTH-ACCOUNT-BW-UTIL-RSVP { |
| description | | description |
| "Information about RSVP-TE bandwidth utilization | | "Information about RSVP-TE bandwidth utilization |
| in bandwidth accounting"; | | in bandwidth accounting"; |
| leaf total-link-bandwidth-utilization { | | leaf total-link-bandwidth-utilization { |
| type uint64; | | type uint64; |
| units "kbit/s"; | | units "kbit/s"; |
| description | | description |
| "Total bandwidth utilization measured in kilobits | | "Total bandwidth utilization measured in kilobits |
| per second"; | | per second"; |
| } | | } |
| leaf rsvp-te-bandwidth-utilization { | | leaf rsvp-te-bandwidth-utilization { |
| type uint64; | | type uint64; |
| units "kbit/s"; | | units "kbit/s"; |
| description | | description |
| "RSVP-TE bandwidth utilization measured in | | "RSVP-TE bandwidth utilization measured in |
| kilobits per second"; | | kilobits per second"; |
| } | | } |
| leaf non-rsvp-te-bandwidth-utilization { | | leaf non-rsvp-te-bandwidth-utilization { |
| type uint64; | | type uint64; |
| units "kbit/s"; | | units "kbit/s"; |
| description | | description |
| "Non-RSVP-TE bandwidth utilization measured in | | "Non-RSVP-TE bandwidth utilization measured in |
| kilobits per second"; | | kilobits per second"; |
| } | | } |
| leaf rsvp-te-adjusted-bandwidth-utilization { | | leaf rsvp-te-adjusted-bandwidth-utilization { |
| type uint64; | | type uint64; |
| units "kbit/s"; | | units "kbit/s"; |
| description | | description |
| "Adjusted RSVP-TE bandwidth utilization measured | | "Adjusted RSVP-TE bandwidth utilization measured |
| in kilobits per second"; | | in kilobits per second"; |
| } | | } |
| leaf rsvp-te-enforced-bandwidth-utilization { | | leaf rsvp-te-enforced-bandwidth-utilization { |
| type uint64; | | type uint64; |
| units "kbit/s"; | | units "kbit/s"; |
| description | | description |
| "Enforced RSVP-TE bandwidth utilization measured | | "Enforced RSVP-TE bandwidth utilization measured |
| in kilobits per second"; | | in kilobits per second"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-LM-BANDWIDTH-ACCOUNT-LINK-TELEMETRY-INFO { | | grouping MPLS-LM-BANDWIDTH-ACCOUNT-LINK-TELEMETRY-INFO { |
| description | | description |
| "Telemetry information for bandwidth accounting | | "Telemetry information for bandwidth accounting |
| per link"; | | per link"; |
| container rsvp-te-bandwidth-utilization { | | container rsvp-te-bandwidth-utilization { |
| description | | description |
| "RSVP-TE bandwidth utilization information"; | | "RSVP-TE bandwidth utilization information"; |
| uses MPLS-TE-BANDWIDTH-ACCOUNT-BW-UTIL-RSVP; | | uses MPLS-TE-BANDWIDTH-ACCOUNT-BW-UTIL-RSVP; |
| } | | } |
| container sr-bandwidth-utilization { | | container sr-bandwidth-utilization { |
| description | | description |
| "Segment Routing bandwidth utilization | | "Segment Routing bandwidth utilization |
| information"; | | information"; |
| uses MPLS-TE-BANDWIDTH-ACCOUNT-BW-UTIL-SR; | | uses MPLS-TE-BANDWIDTH-ACCOUNT-BW-UTIL-SR; |
| } | | } |
| leaf is-bandwidth-account-enabled { | | leaf is-bandwidth-account-enabled { |
| type boolean; | | type boolean; |
| description | | description |
| "TRUE if bandwidth accounting is enabled"; | | "TRUE if bandwidth accounting is enabled"; |
| } | | } |
| leaf application-enforced { | | leaf application-enforced { |
| type boolean; | | type boolean; |
| description | | description |
| "TRUE if application is enforced"; | | "TRUE if application is enforced"; |
| } | | } |
| leaf collection-type { | | leaf collection-type { |
| type Bandwidth-accounting-collection; | | type Bandwidth-accounting-collection; |
| description | | description |
| "The type of traffic collected for bandwidth | | "The type of traffic collected for bandwidth |
| accounting"; | | accounting"; |
| } | | } |
| leaf sample-time-remaining-timestamp-nanosec { | | leaf sample-time-remaining-timestamp-nanosec { |
| type uint64; | | type uint64; |
| units "nanosecond"; | | units "nanosecond"; |
| description | | description |
| "This value indicates the number of nano-seconds | | "This value indicates the number of nano-seconds |
| until the next sampling"; | | until the next sampling"; |
| } | | } |
| leaf last-sample-collection-timestamp-nanosec { | | leaf last-sample-collection-timestamp-nanosec { |
| type uint64; | | type uint64; |
| units "nanosecond"; | | units "nanosecond"; |
| description | | description |
| "Timestamp for the last sample collection in | | "Timestamp for the last sample collection in |
| nano-seconds"; | | nano-seconds"; |
| } | | } |
| leaf next-sample-collection-nanosec { | | leaf next-sample-collection-nanosec { |
| type uint64; | | type uint64; |
| units "nanosecond"; | | units "nanosecond"; |
| description | | description |
| "Timestamp for the next sample collection in | | "Timestamp for the next sample collection in |
| nano-seconds"; | | nano-seconds"; |
| } | | } |
| leaf application-time-remaining-nanosec { | | leaf application-time-remaining-nanosec { |
| type uint64; | | type uint64; |
| units "nanosecond"; | | units "nanosecond"; |
| description | | description |
| "This value indicates the number of nano-seconds | | "This value indicates the number of nano-seconds |
| until the next application"; | | until the next application"; |
| } | | } |
| leaf last-application-timestamp-nanosec { | | leaf last-application-timestamp-nanosec { |
| type uint64; | | type uint64; |
| units "nanosecond"; | | units "nanosecond"; |
| description | | description |
| "Timestamp for the last application in | | "Timestamp for the last application in |
| nano-seconds"; | | nano-seconds"; |
| } | | } |
| leaf next-application-timestamp-nanosec { | | leaf next-application-timestamp-nanosec { |
| type uint64; | | type uint64; |
| units "nanosecond"; | | units "nanosecond"; |
| description | | description |
| "Timestamp for the next application in | | "Timestamp for the next application in |
| nano-seconds"; | | nano-seconds"; |
| } | | } |
| leaf effective-maximum-reservable-bandwidth { | | leaf effective-maximum-reservable-bandwidth { |
| type uint64; | | type uint64; |
| description | | description |
| "Maximum reservable bandwidth effective"; | | "Maximum reservable bandwidth effective"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-LM-BANDWIDTH-ACCOUNT-LINK-TEL-DET-INFO { | | grouping MPLS-LM-BANDWIDTH-ACCOUNT-LINK-TEL-DET-INFO { |
| description | | description |
| "Detail telemetry bandwidth accounting information | | "Detail telemetry bandwidth accounting information |
| per link"; | | per link"; |
| container common-info { | | container common-info { |
| description | | description |
| "Information for bandwidth accounting telemetry"; | | "Information for bandwidth accounting telemetry"; |
| uses MPLS-LM-BANDWIDTH-ACCOUNT-LINK-TELEMETRY-INFO; | | uses MPLS-LM-BANDWIDTH-ACCOUNT-LINK-TELEMETRY-INFO; |
| } | | } |
| container rsvp-te-sample-history { | | container rsvp-te-sample-history { |
| description | | description |
| "History of bandwidth accounting RSVP-TE samples"; | | "History of bandwidth accounting RSVP-TE samples"; |
| uses MPLS-TE-BANDWIDTH-ACCOUNT-HISTORY-RSVP; | | uses MPLS-TE-BANDWIDTH-ACCOUNT-HISTORY-RSVP; |
| } | | } |
| container sr-sample-history { | | container sr-sample-history { |
| description | | description |
| "History of bandwidth accounting Segment Routing | | "History of bandwidth accounting Segment Routing |
| samples"; | | samples"; |
| uses MPLS-TE-BANDWIDTH-ACCOUNT-HISTORY-SR; | | uses MPLS-TE-BANDWIDTH-ACCOUNT-HISTORY-SR; |
| } | | } |
| leaf link-id { | | leaf link-id { |
| type string; | | type string; |
| description | | description |
| "The link's ID"; | | "The link's ID"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-MGMT-WDM-CAPABILITIES { | | grouping MPLS-TE-MGMT-WDM-CAPABILITIES { |
| description | | description |
| "GMPLS WDM Capabilities"; | | "GMPLS WDM Capabilities"; |
| leaf grid { | | leaf grid { |
| type Gmpls-uni-mgmt-wdm-grid; | | type Gmpls-uni-mgmt-wdm-grid; |
| description | | description |
| "Grid"; | | "Grid"; |
| } | | } |
| leaf channel-spacing { | | leaf channel-spacing { |
| type Gmpls-uni-mgmt-dwdm-cs; | | type Gmpls-uni-mgmt-dwdm-cs; |
| description | | description |
| "Channel spacing"; | | "Channel spacing"; |
| } | | } |
| leaf default-channel { | | leaf default-channel { |
| type int16; | | type int16; |
| description | | description |
| "Default channel number"; | | "Default channel number"; |
| } | | } |
| list usable-channel { | | list usable-channel { |
| description | | description |
| "List of usable channels"; | | "List of usable channels"; |
| leaf entry { | | leaf entry { |
| type int16; | | type int16; |
| description | | description |
| "List of usable channels"; | | "List of usable channels"; |
| } | | } |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-MGMT-WDM-UNI-LINK { | | grouping MPLS-TE-MGMT-WDM-UNI-LINK { |
| description | | description |
| "GMPLS WDM-UNI link"; | | "GMPLS WDM-UNI link"; |
| container wdm-capabilities { | | container wdm-capabilities { |
| description | | description |
| "WDM capabilities"; | | "WDM capabilities"; |
| uses MPLS-TE-MGMT-WDM-CAPABILITIES; | | uses MPLS-TE-MGMT-WDM-CAPABILITIES; |
| } | | } |
| leaf link-exists { | | leaf link-exists { |
| type boolean; | | type boolean; |
| description | | description |
| "Flag to indicate whether the link exists in the | | "Flag to indicate whether the link exists in the |
| system"; | | system"; |
| } | | } |
| leaf admin-state-up { | | leaf admin-state-up { |
| type boolean; | | type boolean; |
| description | | description |
| "Is the interface administratively UP"; | | "Is the interface administratively UP"; |
| } | | } |
| leaf oper-state-up { | | leaf oper-state-up { |
| type boolean; | | type boolean; |
| description | | description |
| "Is the interface operationally UP"; | | "Is the interface operationally UP"; |
| } | | } |
| leaf bw-locked-upstream { | | leaf bw-locked-upstream { |
| type boolean; | | type boolean; |
| description | | description |
| "Is the interface bandwidth locked in the | | "Is the interface bandwidth locked in the |
| upstream direction"; | | upstream direction"; |
| } | | } |
| leaf bw-locked-downstream { | | leaf bw-locked-downstream { |
| type boolean; | | type boolean; |
| description | | description |
| "Is the interface bandwidth locked in the | | "Is the interface bandwidth locked in the |
| downstream direction"; | | downstream direction"; |
| } | | } |
| leaf admitted-lsp-id { | | leaf admitted-lsp-id { |
| type uint16; | | type uint16; |
| description | | description |
| "LSP-ID admitted on this optical link. Not valid | | "LSP-ID admitted on this optical link. Not valid |
| if neither the upstream nor downstream bandwidth | | if neither the upstream nor downstream bandwidth |
| is locked"; | | is locked"; |
| } | | } |
| leaf lmp-router-id { | | leaf lmp-router-id { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "LMP GMPLS Optical-UNI router-id"; | | "LMP GMPLS Optical-UNI router-id"; |
| } | | } |
| leaf lmp-adj-state-up { | | leaf lmp-adj-state-up { |
| type boolean; | | type boolean; |
| description | | description |
| "Is the LMP optical adjacency UP"; | | "Is the LMP optical adjacency UP"; |
| } | | } |
| leaf lmpipcc-state-up { | | leaf lmpipcc-state-up { |
| type boolean; | | type boolean; |
| description | | description |
| "If the LMP IP control channel up ?"; | | "If the LMP IP control channel up ?"; |
| } | | } |
| leaf lmp-neighbor-name { | | leaf lmp-neighbor-name { |
| type string; | | type string; |
| description | | description |
| "LMP neighbor Name"; | | "LMP neighbor Name"; |
| } | | } |
| leaf lmp-neighbor-router-id { | | leaf lmp-neighbor-router-id { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "LMP neighbor router ID addres"; | | "LMP neighbor router ID addres"; |
| } | | } |
| leaf lmp-neighbor-ipcc-address { | | leaf lmp-neighbor-ipcc-address { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "The LMP neighbor's IPCC address"; | | "The LMP neighbor's IPCC address"; |
| } | | } |
| leaf lmp-local-ipcc-address { | | leaf lmp-local-ipcc-address { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "The LMP local IPCC address"; | | "The LMP local IPCC address"; |
| } | | } |
| leaf lmp-local-interface-id { | | leaf lmp-local-interface-id { |
| type uint32; | | type uint32; |
| description | | description |
| "The LMP local interface ID"; | | "The LMP local interface ID"; |
| } | | } |
| leaf lmp-neighbor-interface-id { | | leaf lmp-neighbor-interface-id { |
| type uint32; | | type uint32; |
| description | | description |
| "The LMP neighbor interface ID"; | | "The LMP neighbor interface ID"; |
| } | | } |
| leaf lmp-local-link-id { | | leaf lmp-local-link-id { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "The LMP local Link ID"; | | "The LMP local Link ID"; |
| } | | } |
| leaf lmp-neighbor-link-id { | | leaf lmp-neighbor-link-id { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "The LMP neighbor Link ID"; | | "The LMP neighbor Link ID"; |
| } | | } |
| leaf lmp-local-switching-capability { | | leaf lmp-local-switching-capability { |
| type Igpte-link-switch-capability; | | type Igpte-link-switch-capability; |
| description | | description |
| "The LMP local link switching capability"; | | "The LMP local link switching capability"; |
| } | | } |
| leaf lmp-neighbor-switching-capability { | | leaf lmp-neighbor-switching-capability { |
| type Igpte-link-switch-capability; | | type Igpte-link-switch-capability; |
| description | | description |
| "The LMP neighbor link switching capability"; | | "The LMP neighbor link switching capability"; |
| } | | } |
| leaf lmp-local-encoding { | | leaf lmp-local-encoding { |
| type Igpte-link-encoding-protocol; | | type Igpte-link-encoding-protocol; |
| description | | description |
| "The LMP local link encoding type"; | | "The LMP local link encoding type"; |
| } | | } |
| leaf local-link-gpid { | | leaf local-link-gpid { |
| type uint16; | | type uint16; |
| description | | description |
| "The GPID of the local link"; | | "The GPID of the local link"; |
| } | | } |
| leaf srl-gs-announced { | | leaf srl-gs-announced { |
| type boolean; | | type boolean; |
| description | | description |
| "TRUE if discovered SRLGs are announced to L3 | | "TRUE if discovered SRLGs are announced to L3 |
| interface"; | | interface"; |
| } | | } |
| leaf srlg-announced-interface { | | leaf srlg-announced-interface { |
| type string; | | type string; |
| description | | description |
| "The L3 interface that discovered SRLGs are | | "The L3 interface that discovered SRLGs are |
| announced to"; | | announced to"; |
| } | | } |
| leaf local-link-switching-type { | | leaf local-link-switching-type { |
| type Igpte-link-switch-capability; | | type Igpte-link-switch-capability; |
| description | | description |
| "Locally-configured switching type on this link"; | | "Locally-configured switching type on this link"; |
| } | | } |
| leaf local-link-mtu { | | leaf local-link-mtu { |
| type uint16; | | type uint16; |
| description | | description |
| "The MTU of the local link"; | | "The MTU of the local link"; |
| } | | } |
| list local-srlg { | | list local-srlg { |
| description | | description |
| "Locally-configured SRLGs on this link"; | | "Locally-configured SRLGs on this link"; |
| leaf entry { | | leaf entry { |
| type uint32; | | type uint32; |
| description | | description |
| "Locally-configured SRLGs on this link"; | | "Locally-configured SRLGs on this link"; |
| } | | } |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-MGMT-WDM-UNI-CONTROLLER { | | grouping MPLS-TE-MGMT-WDM-UNI-CONTROLLER { |
| description | | description |
| "A GMPLS WDM-UNI controller"; | | "A GMPLS WDM-UNI controller"; |
| container link { | | container link { |
| description | | description |
| "Link properties"; | | "Link properties"; |
| uses MPLS-TE-MGMT-WDM-UNI-LINK; | | uses MPLS-TE-MGMT-WDM-UNI-LINK; |
| } | | } |
| container labels { | | container labels { |
| description | | description |
| "Labels"; | | "Labels"; |
| uses MPLS-TE-MGMT-GMPLS-LABELS; | | uses MPLS-TE-MGMT-GMPLS-LABELS; |
| } | | } |
| container tunnel { | | container tunnel { |
| description | | description |
| "Tunnel info"; | | "Tunnel info"; |
| uses MPLS-TE-MGMT-WDM-UNI-TUNNEL-INFO; | | uses MPLS-TE-MGMT-WDM-UNI-TUNNEL-INFO; |
| } | | } |
| leaf controller-name-xr { | | leaf controller-name-xr { |
| type string; | | type string; |
| description | | description |
| "Interface Name"; | | "Interface Name"; |
| } | | } |
| leaf controller-name-brief { | | leaf controller-name-brief { |
| type string; | | type string; |
| description | | description |
| "Brief Interface Name"; | | "Brief Interface Name"; |
| } | | } |
| leaf child-interface-name { | | leaf child-interface-name { |
| type string; | | type string; |
| description | | description |
| "Child interface name"; | | "Child interface name"; |
| } | | } |
| leaf child-interface-state { | | leaf child-interface-state { |
| type Im-state-enum; | | type Im-state-enum; |
| description | | description |
| "Child Interface State"; | | "Child Interface State"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-NNI-OTN-LINK-ADMITTED-S2L-INFO { | | grouping MPLS-TE-NNI-OTN-LINK-ADMITTED-S2L-INFO { |
| description | | description |
| "Info of S2Ls Admitted to NNI OTN link"; | | "Info of S2Ls Admitted to NNI OTN link"; |
| container s2l-fec { | | container s2l-fec { |
| description | | description |
| "S2L FEC"; | | "S2L FEC"; |
| uses TE-S2L-FEC; | | uses TE-S2L-FEC; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-NNI-OTN-ADMISSION-CONTROL-LINK-INFO { | | grouping MPLS-TE-NNI-OTN-ADMISSION-CONTROL-LINK-INFO { |
| description | | description |
| "Information about a given admitted tunnel"; | | "Information about a given admitted tunnel"; |
| leaf link-name { | | leaf link-name { |
| type string; | | type string; |
| description | | description |
| "The link's name"; | | "The link's name"; |
| } | | } |
| list admitted-s2l { | | list admitted-s2l { |
| description | | description |
| "Admitted S2Ls"; | | "Admitted S2Ls"; |
| uses MPLS-TE-NNI-OTN-LINK-ADMITTED-S2L-INFO; | | uses MPLS-TE-NNI-OTN-LINK-ADMITTED-S2L-INFO; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-NNI-LINK-AREA-INFO { | | grouping MPLS-TE-NNI-LINK-AREA-INFO { |
| description | | description |
| "Information about an area to which the link | | "Information about an area to which the link |
| belongs"; | | belongs"; |
| container remote-te-link-id { | | container remote-te-link-id { |
| description | | description |
| "Remote link id in this topology instance"; | | "Remote link id in this topology instance"; |
| uses TE-ADDR; | | uses TE-ADDR; |
| } | | } |
| leaf igp-type { | | leaf igp-type { |
| type Igp-protocol; | | type Igp-protocol; |
| description | | description |
| "IGP type"; | | "IGP type"; |
| } | | } |
| leaf igp-instance-id { | | leaf igp-instance-id { |
| type string; | | type string; |
| description | | description |
| "Igp instance ID"; | | "Igp instance ID"; |
| } | | } |
| leaf igp-area-id-format { | | leaf igp-area-id-format { |
| type Igp-ospf-area-format; | | type Igp-ospf-area-format; |
| description | | description |
| "Igp area id format"; | | "Igp area id format"; |
| } | | } |
| leaf igp-area-id { | | leaf igp-area-id { |
| type uint32; | | type uint32; |
| description | | description |
| "Igp area id"; | | "Igp area id"; |
| } | | } |
| leaf te-metric { | | leaf te-metric { |
| type uint32; | | type uint32; |
| description | | description |
| "The link's TE metric"; | | "The link's TE metric"; |
| } | | } |
| leaf uni-link-delay-configured { | | leaf uni-link-delay-configured { |
| type uint32; | | type uint32; |
| description | | description |
| "Unidirectional Link Delay configured in | | "Unidirectional Link Delay configured in |
| micro-sec"; | | micro-sec"; |
| } | | } |
| leaf uni-link-delay-computed { | | leaf uni-link-delay-computed { |
| type uint32; | | type uint32; |
| description | | description |
| "Unidirectional Link Delay computed in micro-sec"; | | "Unidirectional Link Delay computed in micro-sec"; |
| } | | } |
| leaf uni-link-delay-to-flood { | | leaf uni-link-delay-to-flood { |
| type uint32; | | type uint32; |
| description | | description |
| "Unidirectional Link Delay to flood in micro-sec"; | | "Unidirectional Link Delay to flood in micro-sec"; |
| } | | } |
| leaf reason-not-flooded { | | leaf reason-not-flooded { |
| type Mpls-te-reason-not-flooded; | | type Mpls-te-reason-not-flooded; |
| description | | description |
| "Reason why link is not flooded"; | | "Reason why link is not flooded"; |
| } | | } |
| leaf igp-area-address { | | leaf igp-area-address { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "IGP's area IP address"; | | "IGP's area IP address"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-NNI-OTN-LINK-INFO { | | grouping MPLS-TE-NNI-OTN-LINK-INFO { |
| description | | description |
| "IGP and area information of a TE NNI OTN link"; | | "IGP and area information of a TE NNI OTN link"; |
| container local-link-id { | | container local-link-id { |
| description | | description |
| "Local TE link ID"; | | "Local TE link ID"; |
| uses TE-ADDR; | | uses TE-ADDR; |
| } | | } |
| container odu-link-capabilities { | | container odu-link-capabilities { |
| description | | description |
| "ODU capabilities of Link"; | | "ODU capabilities of Link"; |
| uses ODU-LINK-CAPABILITIES; | | uses ODU-LINK-CAPABILITIES; |
| } | | } |
| leaf link-name { | | leaf link-name { |
| type string; | | type string; |
| description | | description |
| "The link's name"; | | "The link's name"; |
| } | | } |
| leaf interface-handle { | | leaf interface-handle { |
| type xr:Interface-name; | | type xr:Interface-name; |
| description | | description |
| "Link interface handle"; | | "Link interface handle"; |
| } | | } |
| leaf link-state { | | leaf link-state { |
| type Te-controller-state; | | type Te-controller-state; |
| description | | description |
| "Link state"; | | "Link state"; |
| } | | } |
| leaf resource-provider { | | leaf resource-provider { |
| type Resource-provider; | | type Resource-provider; |
| description | | description |
| "The link's resource provider"; | | "The link's resource provider"; |
| } | | } |
| leaf physical-bandwidth { | | leaf physical-bandwidth { |
| type Otu; | | type Otu; |
| description | | description |
| "The link's physical bandwidth"; | | "The link's physical bandwidth"; |
| } | | } |
| leaf tti-mode { | | leaf tti-mode { |
| type Tti-mode; | | type Tti-mode; |
| description | | description |
| "SM,PM or TCM mode for controller"; | | "SM,PM or TCM mode for controller"; |
| } | | } |
| leaf tandem-connection-monitoring { | | leaf tandem-connection-monitoring { |
| type uint8; | | type uint8; |
| description | | description |
| "Tandem connection monitoring to carry link id, 0 | | "Tandem connection monitoring to carry link id, 0 |
| if PM"; | | if PM"; |
| } | | } |
| leaf igp-neighbors-count { | | leaf igp-neighbors-count { |
| type uint16; | | type uint16; |
| description | | description |
| "The link's neighbor count"; | | "The link's neighbor count"; |
| } | | } |
| leaf link-attributes { | | leaf link-attributes { |
| type uint32; | | type uint32; |
| description | | description |
| "Deprecated"; | | "Deprecated"; |
| } | | } |
| leaf is-attribute-incomplete { | | leaf is-attribute-incomplete { |
| type boolean; | | type boolean; |
| description | | description |
| "TRUE if one or more affinity definition(s) | | "TRUE if one or more affinity definition(s) |
| is/are unknown"; | | is/are unknown"; |
| } | | } |
| leaf is-name-based-attribute { | | leaf is-name-based-attribute { |
| type boolean; | | type boolean; |
| description | | description |
| "TRUE, if name based attribute style is in effect"; | | "TRUE, if name based attribute style is in effect"; |
| } | | } |
| list link-extended-attribute { | | list link-extended-attribute { |
| description | | description |
| "The link's extended attribute bit map"; | | "The link's extended attribute bit map"; |
| leaf entry { | | leaf entry { |
| type uint32; | | type uint32; |
| description | | description |
| "The link's extended attribute bit map"; | | "The link's extended attribute bit map"; |
| } | | } |
| } | | } |
| list link-forwad-ref-value { | | list link-forwad-ref-value { |
| description | | description |
| "Reference bits for undefined affinity names"; | | "Reference bits for undefined affinity names"; |
| leaf entry { | | leaf entry { |
| type uint32; | | type uint32; |
| description | | description |
| "Reference bits for undefined affinity names"; | | "Reference bits for undefined affinity names"; |
| } | | } |
| } | | } |
| list srl-gs { | | list srl-gs { |
| description | | description |
| "The link's shared risk link groups"; | | "The link's shared risk link groups"; |
| uses MPLS-SRLG-INFO; | | uses MPLS-SRLG-INFO; |
| } | | } |
| list igp-areas { | | list igp-areas { |
| description | | description |
| "Per-IGP area data"; | | "Per-IGP area data"; |
| uses MPLS-TE-NNI-LINK-AREA-INFO; | | uses MPLS-TE-NNI-LINK-AREA-INFO; |
| } | | } |
| list affinity-map { | | list affinity-map { |
| description | | description |
| "Affinity map array"; | | "Affinity map array"; |
| uses MPLS-TE-AFFINITY-MAP-INFO; | | uses MPLS-TE-AFFINITY-MAP-INFO; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-NNI-OTN-SUMMARY-INFO { | | grouping MPLS-TE-NNI-OTN-SUMMARY-INFO { |
| description | | description |
| "Global info about links"; | | "Global info about links"; |
| leaf is-role-standby { | | leaf is-role-standby { |
| type boolean; | | type boolean; |
| description | | description |
| "TRUE if Role is Standby, False if Active"; | | "TRUE if Role is Standby, False if Active"; |
| } | | } |
| leaf nni-otn-links { | | leaf nni-otn-links { |
| type uint16; | | type uint16; |
| description | | description |
| "The number of NNI OTN links"; | | "The number of NNI OTN links"; |
| } | | } |
| leaf nni-otn-links-max { | | leaf nni-otn-links-max { |
| type uint16; | | type uint16; |
| description | | description |
| "Maximum number of NNI links supported"; | | "Maximum number of NNI links supported"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-LM-BW-LINK-BW-POOL-INFO { | | grouping MPLS-LM-BW-LINK-BW-POOL-INFO { |
| description | | description |
| "Information about the bandwidth of a given pool | | "Information about the bandwidth of a given pool |
| and priority"; | | and priority"; |
| leaf hold-priority { | | leaf hold-priority { |
| type uint8; | | type uint8; |
| description | | description |
| "The BW priority"; | | "The BW priority"; |
| } | | } |
| leaf held-amount { | | leaf held-amount { |
| type uint32; | | type uint32; |
| description | | description |
| "The held bandwidth"; | | "The held bandwidth"; |
| } | | } |
| leaf total-held-amount { | | leaf total-held-amount { |
| type uint32; | | type uint32; |
| description | | description |
| "The total held bandwidth"; | | "The total held bandwidth"; |
| } | | } |
| leaf locked-amount { | | leaf locked-amount { |
| type uint32; | | type uint32; |
| description | | description |
| "The locked bandwidth"; | | "The locked bandwidth"; |
| } | | } |
| leaf total-locked-amount { | | leaf total-locked-amount { |
| type uint32; | | type uint32; |
| description | | description |
| "The total locked bandwidth"; | | "The total locked bandwidth"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-LM-BW-LINK-DIR-BW-INFO { | | grouping MPLS-LM-BW-LINK-DIR-BW-INFO { |
| description | | description |
| "Information about the bandwidth of a given link."; | | "Information about the bandwidth of a given link."; |
| leaf bandwidth-direction { | | leaf bandwidth-direction { |
| type Link-direction-enum; | | type Link-direction-enum; |
| description | | description |
| "BW Direction"; | | "BW Direction"; |
| } | | } |
| leaf is-admission-method-allocated-bandwidth { | | leaf is-admission-method-allocated-bandwidth { |
| type boolean; | | type boolean; |
| description | | description |
| "True if the link's admit method is based on | | "True if the link's admit method is based on |
| Allocated BW"; | | Allocated BW"; |
| } | | } |
| leaf bandwidth-units { | | leaf bandwidth-units { |
| type Bandwidth-unit-enum; | | type Bandwidth-unit-enum; |
| description | | description |
| "Bandwidth units"; | | "Bandwidth units"; |
| } | | } |
| list bandwidth-pool0 { | | list bandwidth-pool0 { |
| max-elements "8"; | | max-elements "8"; |
| description | | description |
| "Pool0 BW info for the different priority levels"; | | "Pool0 BW info for the different priority levels"; |
| uses MPLS-LM-BW-LINK-BW-POOL-INFO; | | uses MPLS-LM-BW-LINK-BW-POOL-INFO; |
| } | | } |
| list bandwidth-pool1 { | | list bandwidth-pool1 { |
| max-elements "8"; | | max-elements "8"; |
| description | | description |
| "Pool1 BW info for the different priority levels"; | | "Pool1 BW info for the different priority levels"; |
| uses MPLS-LM-BW-LINK-BW-POOL-INFO; | | uses MPLS-LM-BW-LINK-BW-POOL-INFO; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-LM-FLOODED-AREA { | | grouping MPLS-LM-FLOODED-AREA { |
| description | | description |
| "Information for the flooded area"; | | "Information for the flooded area"; |
| leaf flooded-area { | | leaf flooded-area { |
| type string; | | type string; |
| description | | description |
| "The flooded area information"; | | "The flooded area information"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-LM-LINK-FLAGS { | | grouping MPLS-LM-LINK-FLAGS { |
| description | | description |
| "Link properties"; | | "Link properties"; |
| leaf is-mpls-te-on { | | leaf is-mpls-te-on { |
| type boolean; | | type boolean; |
| description | | description |
| "Deprecated - TRUE if the link is a TE-Link"; | | "Deprecated - TRUE if the link is a TE-Link"; |
| } | | } |
| leaf signaling-agent { | | leaf signaling-agent { |
| type Signaling-agent-enum; | | type Signaling-agent-enum; |
| description | | description |
| "Deprecated - Signaling agent"; | | "Deprecated - Signaling agent"; |
| } | | } |
| leaf is-admin-up { | | leaf is-admin-up { |
| type boolean; | | type boolean; |
| description | | description |
| "TRUE if the link is admin up"; | | "TRUE if the link is admin up"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-LM-INTF-SWITCHING-CAP-INFO { | | grouping MPLS-LM-INTF-SWITCHING-CAP-INFO { |
| description | | description |
| "Information about the Interface Switching | | "Information about the Interface Switching |
| Capability Descriptor (IXCD)"; | | Capability Descriptor (IXCD)"; |
| leaf key { | | leaf key { |
| type uint8; | | type uint8; |
| description | | description |
| "The switching capability descriptor key"; | | "The switching capability descriptor key"; |
| } | | } |
| leaf switching-capability { | | leaf switching-capability { |
| type uint8; | | type uint8; |
| description | | description |
| "The switching capability"; | | "The switching capability"; |
| } | | } |
| leaf encoding { | | leaf encoding { |
| type uint8; | | type uint8; |
| description | | description |
| "The link encoding type"; | | "The link encoding type"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-LM-COMMON-LINK-INFO { | | grouping MPLS-LM-COMMON-LINK-INFO { |
| description | | description |
| "Link information"; | | "Link information"; |
| container link-flags { | | container link-flags { |
| description | | description |
| "The link's flags"; | | "The link's flags"; |
| uses MPLS-LM-LINK-FLAGS; | | uses MPLS-LM-LINK-FLAGS; |
| } | | } |
| leaf link-id { | | leaf link-id { |
| type string; | | type string; |
| description | | description |
| "The link's id"; | | "The link's id"; |
| } | | } |
| leaf link-address { | | leaf link-address { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "The link's ip address"; | | "The link's ip address"; |
| } | | } |
| leaf is-unnumbered { | | leaf is-unnumbered { |
| type boolean; | | type boolean; |
| description | | description |
| "TRUE if the link is unnumbered"; | | "TRUE if the link is unnumbered"; |
| } | | } |
| leaf has-protection { | | leaf has-protection { |
| type boolean; | | type boolean; |
| description | | description |
| "TRUE if the link is protected"; | | "TRUE if the link is protected"; |
| } | | } |
| leaf capability { | | leaf capability { |
| type uint32; | | type uint32; |
| description | | description |
| "The link's protection capability"; | | "The link's protection capability"; |
| } | | } |
| leaf working-priority { | | leaf working-priority { |
| type uint32; | | type uint32; |
| description | | description |
| "The link's working priority"; | | "The link's working priority"; |
| } | | } |
| leaf resource-provider { | | leaf resource-provider { |
| type Resource-provider; | | type Resource-provider; |
| description | | description |
| "The link's resource provider"; | | "The link's resource provider"; |
| } | | } |
| leaf is-resource-provider-installed { | | leaf is-resource-provider-installed { |
| type boolean; | | type boolean; |
| description | | description |
| "TRUE if the resource provider is installed"; | | "TRUE if the resource provider is installed"; |
| } | | } |
| leaf bandwidth-units { | | leaf bandwidth-units { |
| type Bandwidth-unit-enum; | | type Bandwidth-unit-enum; |
| description | | description |
| "The bandwidth units"; | | "The bandwidth units"; |
| } | | } |
| leaf physical-bandwidth { | | leaf physical-bandwidth { |
| type uint64; | | type uint64; |
| description | | description |
| "The link's physical bandwidth"; | | "The link's physical bandwidth"; |
| } | | } |
| leaf bcm-id { | | leaf bcm-id { |
| type uint16; | | type uint16; |
| description | | description |
| "Bandwidth Constraints Model ID"; | | "Bandwidth Constraints Model ID"; |
| } | | } |
| leaf maximum-reservable-bandwidth { | | leaf maximum-reservable-bandwidth { |
| type uint64; | | type uint64; |
| description | | description |
| "The link's maximum reservable BW"; | | "The link's maximum reservable BW"; |
| } | | } |
| leaf last-flooded-effective-maximum-reservable-bandwidth { | | leaf last-flooded-effective-maximum-reservable-bandwidth { |
| type uint64; | | type uint64; |
| description | | description |
| "Last flooded max reservable bandwidth effective"; | | "Last flooded max reservable bandwidth effective"; |
| } | | } |
| leaf incoming-reservable-bandwidth-percentage { | | leaf incoming-reservable-bandwidth-percentage { |
| type uint8; | | type uint8; |
| description | | description |
| "Incoming reserved BW in %"; | | "Incoming reserved BW in %"; |
| } | | } |
| leaf outgoing-reservable-bandwidth-percentage { | | leaf outgoing-reservable-bandwidth-percentage { |
| type uint8; | | type uint8; |
| description | | description |
| "Outgoing reserved BW in %"; | | "Outgoing reserved BW in %"; |
| } | | } |
| leaf maximum-reservable-pool0-bandwidth { | | leaf maximum-reservable-pool0-bandwidth { |
| type uint64; | | type uint64; |
| description | | description |
| "The link's maximum reservable pool0 BW"; | | "The link's maximum reservable pool0 BW"; |
| } | | } |
| leaf incoming-reservable-pool0-bandwidth-percentage { | | leaf incoming-reservable-pool0-bandwidth-percentage { |
| type uint8; | | type uint8; |
| description | | description |
| "Incoming reserved pool0 BW in %"; | | "Incoming reserved pool0 BW in %"; |
| } | | } |
| leaf outgoing-reservable-pool0-bandwidth-percentage { | | leaf outgoing-reservable-pool0-bandwidth-percentage { |
| type uint8; | | type uint8; |
| description | | description |
| "Outgoing reserved pool0 BW in %"; | | "Outgoing reserved pool0 BW in %"; |
| } | | } |
| leaf maximum-reservable-pool1-bandwidth { | | leaf maximum-reservable-pool1-bandwidth { |
| type uint64; | | type uint64; |
| description | | description |
| "The link's maximum reservable pool1 BW"; | | "The link's maximum reservable pool1 BW"; |
| } | | } |
| leaf incoming-reservable-pool1-bandwidth-percentage { | | leaf incoming-reservable-pool1-bandwidth-percentage { |
| type uint8; | | type uint8; |
| description | | description |
| "Incoming reserved pool1 BW in %"; | | "Incoming reserved pool1 BW in %"; |
| } | | } |
| leaf outgoing-reservable-pool1-bandwidth-percentage { | | leaf outgoing-reservable-pool1-bandwidth-percentage { |
| type uint8; | | type uint8; |
| description | | description |
| "Outgoing reserved pool1 BW in %"; | | "Outgoing reserved pool1 BW in %"; |
| } | | } |
| leaf inbound-admission-method { | | leaf inbound-admission-method { |
| type Admission-policy; | | type Admission-policy; |
| description | | description |
| "Deprecated"; | | "Deprecated"; |
| } | | } |
| leaf outbound-admission-method { | | leaf outbound-admission-method { |
| type Admission-policy; | | type Admission-policy; |
| description | | description |
| "Deprecated"; | | "Deprecated"; |
| } | | } |
| leaf igp-neighbors { | | leaf igp-neighbors { |
| type uint16; | | type uint16; |
| description | | description |
| "The link's neighbor count"; | | "The link's neighbor count"; |
| } | | } |
| list shared-risk-link-group { | | list shared-risk-link-group { |
| description | | description |
| "The link's shared risk link groups"; | | "The link's shared risk link groups"; |
| uses MPLS-SRLG-INFO; | | uses MPLS-SRLG-INFO; |
| } | | } |
| list interface-switching-capability-descriptor { | | list interface-switching-capability-descriptor { |
| description | | description |
| "The link's switching capability descriptor"; | | "The link's switching capability descriptor"; |
| uses MPLS-LM-INTF-SWITCHING-CAP-INFO; | | uses MPLS-LM-INTF-SWITCHING-CAP-INFO; |
| } | | } |
| list flooded-areas { | | list flooded-areas { |
| description | | description |
| "List of areas into which the link is flooded"; | | "List of areas into which the link is flooded"; |
| uses MPLS-LM-FLOODED-AREA; | | uses MPLS-LM-FLOODED-AREA; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-LM-BW-ALLOC-LINK-INFO { | | grouping MPLS-LM-BW-ALLOC-LINK-INFO { |
| description | | description |
| "Bandwidth allocation information for a given link"; | | "Bandwidth allocation information for a given link"; |
| container link-common { | | container link-common { |
| description | | description |
| "The link's common info"; | | "The link's common info"; |
| uses MPLS-LM-COMMON-LINK-INFO; | | uses MPLS-LM-COMMON-LINK-INFO; |
| } | | } |
| container upstream-bandwidth { | | container upstream-bandwidth { |
| description | | description |
| "BW info in the upstream direction"; | | "BW info in the upstream direction"; |
| uses MPLS-LM-BW-LINK-DIR-BW-INFO; | | uses MPLS-LM-BW-LINK-DIR-BW-INFO; |
| } | | } |
| container downstream-bandwidth { | | container downstream-bandwidth { |
| description | | description |
| "BW info in the dnstream direction"; | | "BW info in the dnstream direction"; |
| uses MPLS-LM-BW-LINK-DIR-BW-INFO; | | uses MPLS-LM-BW-LINK-DIR-BW-INFO; |
| } | | } |
| leaf total-bandwidth-descriptors { | | leaf total-bandwidth-descriptors { |
| type uint16; | | type uint16; |
| description | | description |
| "Number of total BW descriptors"; | | "Number of total BW descriptors"; |
| } | | } |
| leaf bandwidth-descriptors { | | leaf bandwidth-descriptors { |
| type uint16; | | type uint16; |
| description | | description |
| "Number of BW descriptor for the given pool"; | | "Number of BW descriptor for the given pool"; |
| } | | } |
| leaf bandwidth-pool { | | leaf bandwidth-pool { |
| type Bandwidth-type-enum; | | type Bandwidth-type-enum; |
| description | | description |
| "type of the BW pool"; | | "type of the BW pool"; |
| } | | } |
| leaf flooding-up-thresholds-are-default { | | leaf flooding-up-thresholds-are-default { |
| type boolean; | | type boolean; |
| description | | description |
| "TRUE if the up-threshold are default"; | | "TRUE if the up-threshold are default"; |
| } | | } |
| leaf flooding-down-thresholds-are-default { | | leaf flooding-down-thresholds-are-default { |
| type boolean; | | type boolean; |
| description | | description |
| "TRUE if the down-threshold are default"; | | "TRUE if the down-threshold are default"; |
| } | | } |
| leaf flooding-up-thresholds-are-global { | | leaf flooding-up-thresholds-are-global { |
| type boolean; | | type boolean; |
| description | | description |
| "TRUE if the up-threshold are global"; | | "TRUE if the up-threshold are global"; |
| } | | } |
| leaf flooding-down-thresholds-are-global { | | leaf flooding-down-thresholds-are-global { |
| type boolean; | | type boolean; |
| description | | description |
| "TRUE if the down-threshold are global"; | | "TRUE if the down-threshold are global"; |
| } | | } |
| list flooding-up-threshold { | | list flooding-up-threshold { |
| description | | description |
| "Flooding up-thresholds"; | | "Flooding up-thresholds"; |
| leaf entry { | | leaf entry { |
| type uint8; | | type uint8; |
| description | | description |
| "Flooding up-thresholds"; | | "Flooding up-thresholds"; |
| } | | } |
| } | | } |
| list flooding-down-threshold { | | list flooding-down-threshold { |
| description | | description |
| "Flooding down-thresholds"; | | "Flooding down-thresholds"; |
| leaf entry { | | leaf entry { |
| type uint8; | | type uint8; |
| description | | description |
| "Flooding down-thresholds"; | | "Flooding down-thresholds"; |
| } | | } |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-LM-BW-ALLOC-COMMON-INFO { | | grouping MPLS-LM-BW-ALLOC-COMMON-INFO { |
| description | | description |
| "Common information about bandwidth allocation"; | | "Common information about bandwidth allocation"; |
| leaf is-role-standby { | | leaf is-role-standby { |
| type boolean; | | type boolean; |
| description | | description |
| "TRUE if Role is Standby, Active otherwise"; | | "TRUE if Role is Standby, Active otherwise"; |
| } | | } |
| leaf links { | | leaf links { |
| type uint16; | | type uint16; |
| description | | description |
| "Number of links"; | | "Number of links"; |
| } | | } |
| leaf bandwidth-hold-time { | | leaf bandwidth-hold-time { |
| type uint16; | | type uint16; |
| units "second"; | | units "second"; |
| description | | description |
| "How long to hold the bandwidth (seconds)"; | | "How long to hold the bandwidth (seconds)"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-LM-STATS-LINK-INFO { | | grouping MPLS-LM-STATS-LINK-INFO { |
| description | | description |
| "Statistics for a link"; | | "Statistics for a link"; |
| container incoming-path-statistics { | | container incoming-path-statistics { |
| description | | description |
| "Deprecated"; | | "Deprecated"; |
| uses MPLS-LM-STATS-COUNTERS; | | uses MPLS-LM-STATS-COUNTERS; |
| } | | } |
| container incoming-reservation-statistics { | | container incoming-reservation-statistics { |
| description | | description |
| "Deprecated"; | | "Deprecated"; |
| uses MPLS-LM-STATS-COUNTERS; | | uses MPLS-LM-STATS-COUNTERS; |
| } | | } |
| container outgoing-path-statistics { | | container outgoing-path-statistics { |
| description | | description |
| "Deprecated"; | | "Deprecated"; |
| uses MPLS-LM-STATS-COUNTERS; | | uses MPLS-LM-STATS-COUNTERS; |
| } | | } |
| container outgoing-reservation-statistics { | | container outgoing-reservation-statistics { |
| description | | description |
| "Deprecated"; | | "Deprecated"; |
| uses MPLS-LM-STATS-COUNTERS; | | uses MPLS-LM-STATS-COUNTERS; |
| } | | } |
| container incoming-path-statistics32-bit { | | container incoming-path-statistics32-bit { |
| description | | description |
| "Incoming PATH counters"; | | "Incoming PATH counters"; |
| uses MPLS-LM-STATS-COUNTERS-32-BIT; | | uses MPLS-LM-STATS-COUNTERS-32-BIT; |
| } | | } |
| container incoming-reservation-statistics32-bit { | | container incoming-reservation-statistics32-bit { |
| description | | description |
| "Incoming RESV counters"; | | "Incoming RESV counters"; |
| uses MPLS-LM-STATS-COUNTERS-32-BIT; | | uses MPLS-LM-STATS-COUNTERS-32-BIT; |
| } | | } |
| container outgoing-path-statistics32-bit { | | container outgoing-path-statistics32-bit { |
| description | | description |
| "Outgoing PATH counters"; | | "Outgoing PATH counters"; |
| uses MPLS-LM-STATS-COUNTERS-32-BIT; | | uses MPLS-LM-STATS-COUNTERS-32-BIT; |
| } | | } |
| container outgoing-reservation-statistics32-bit { | | container outgoing-reservation-statistics32-bit { |
| description | | description |
| "Outgoing RESV counters"; | | "Outgoing RESV counters"; |
| uses MPLS-LM-STATS-COUNTERS-32-BIT; | | uses MPLS-LM-STATS-COUNTERS-32-BIT; |
| } | | } |
| leaf interface-name-xr { | | leaf interface-name-xr { |
| type string; | | type string; |
| description | | description |
| "Link name"; | | "Link name"; |
| } | | } |
| leaf link-address { | | leaf link-address { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Link's ip address"; | | "Link's ip address"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-LM-STATS-COUNTERS-32-BIT { | | grouping MPLS-LM-STATS-COUNTERS-32-BIT { |
| description | | description |
| "Statistics for Setup and Tear processing (32 bit)"; | | "Statistics for Setup and Tear processing (32 bit)"; |
| leaf setup-requests { | | leaf setup-requests { |
| type uint32; | | type uint32; |
| description | | description |
| "Setup requests"; | | "Setup requests"; |
| } | | } |
| leaf setup-errors { | | leaf setup-errors { |
| type uint32; | | type uint32; |
| description | | description |
| "Setup errors"; | | "Setup errors"; |
| } | | } |
| leaf setup-admits { | | leaf setup-admits { |
| type uint32; | | type uint32; |
| description | | description |
| "Setup admits"; | | "Setup admits"; |
| } | | } |
| leaf setup-rejects { | | leaf setup-rejects { |
| type uint32; | | type uint32; |
| description | | description |
| "Setup rejects"; | | "Setup rejects"; |
| } | | } |
| leaf tear-requests { | | leaf tear-requests { |
| type uint32; | | type uint32; |
| description | | description |
| "Tear requests"; | | "Tear requests"; |
| } | | } |
| leaf tear-errors { | | leaf tear-errors { |
| type uint32; | | type uint32; |
| description | | description |
| "Tear errors"; | | "Tear errors"; |
| } | | } |
| leaf tear-preempts { | | leaf tear-preempts { |
| type uint32; | | type uint32; |
| description | | description |
| "Tear preempts"; | | "Tear preempts"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-LM-STATS-COUNTERS { | | grouping MPLS-LM-STATS-COUNTERS { |
| description | | description |
| "DEPRECATED, use of mpls_lm_stats_counters_32_bit | | "DEPRECATED, use of mpls_lm_stats_counters_32_bit |
| recommended"; | | recommended"; |
| leaf setup-requests { | | leaf setup-requests { |
| type uint16; | | type uint16; |
| description | | description |
| "Deprecated"; | | "Deprecated"; |
| } | | } |
| leaf setup-errors { | | leaf setup-errors { |
| type uint16; | | type uint16; |
| description | | description |
| "Deprecated"; | | "Deprecated"; |
| } | | } |
| leaf setup-admits { | | leaf setup-admits { |
| type uint16; | | type uint16; |
| description | | description |
| "Deprecated"; | | "Deprecated"; |
| } | | } |
| leaf setup-rejects { | | leaf setup-rejects { |
| type uint16; | | type uint16; |
| description | | description |
| "Deprecated"; | | "Deprecated"; |
| } | | } |
| leaf tear-requests { | | leaf tear-requests { |
| type uint16; | | type uint16; |
| description | | description |
| "Deprecated"; | | "Deprecated"; |
| } | | } |
| leaf tear-errors { | | leaf tear-errors { |
| type uint16; | | type uint16; |
| description | | description |
| "Deprecated"; | | "Deprecated"; |
| } | | } |
| leaf tear-preempts { | | leaf tear-preempts { |
| type uint16; | | type uint16; |
| description | | description |
| "Deprecated"; | | "Deprecated"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-LM-STATS-SUMMARY-INFO { | | grouping MPLS-LM-STATS-SUMMARY-INFO { |
| description | | description |
| "Statistics for Path and Reservation processing"; | | "Statistics for Path and Reservation processing"; |
| container path-statistics { | | container path-statistics { |
| description | | description |
| "Deprecated"; | | "Deprecated"; |
| uses MPLS-LM-STATS-COUNTERS; | | uses MPLS-LM-STATS-COUNTERS; |
| } | | } |
| container reservation-statistics { | | container reservation-statistics { |
| description | | description |
| "Deprecated"; | | "Deprecated"; |
| uses MPLS-LM-STATS-COUNTERS; | | uses MPLS-LM-STATS-COUNTERS; |
| } | | } |
| container path-statistics32-bit { | | container path-statistics32-bit { |
| description | | description |
| "Path counters (32-bit)"; | | "Path counters (32-bit)"; |
| uses MPLS-LM-STATS-COUNTERS-32-BIT; | | uses MPLS-LM-STATS-COUNTERS-32-BIT; |
| } | | } |
| container reservation-statistics32-bit { | | container reservation-statistics32-bit { |
| description | | description |
| "Reservation counters (32-bit)"; | | "Reservation counters (32-bit)"; |
| uses MPLS-LM-STATS-COUNTERS-32-BIT; | | uses MPLS-LM-STATS-COUNTERS-32-BIT; |
| } | | } |
| leaf is-role-standby { | | leaf is-role-standby { |
| type boolean; | | type boolean; |
| description | | description |
| "TRUE if Role is Standby, Active otherwise"; | | "TRUE if Role is Standby, Active otherwise"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-LM-ADV-LINK-RESV-BW { | | grouping MPLS-LM-ADV-LINK-RESV-BW { |
| description | | description |
| "Information about a link bandwidth"; | | "Information about a link bandwidth"; |
| leaf priority { | | leaf priority { |
| type uint8; | | type uint8; |
| description | | description |
| "The priority level of this bandwidth"; | | "The priority level of this bandwidth"; |
| } | | } |
| leaf pool0-bandwidth { | | leaf pool0-bandwidth { |
| type uint32; | | type uint32; |
| description | | description |
| "The reservable pool0 BW at this priority"; | | "The reservable pool0 BW at this priority"; |
| } | | } |
| leaf pool1-bandwidth { | | leaf pool1-bandwidth { |
| type uint32; | | type uint32; |
| description | | description |
| "The reservable pool1 BW at this priority"; | | "The reservable pool1 BW at this priority"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-LM-ADV-FLOODED-LINK { | | grouping MPLS-LM-ADV-FLOODED-LINK { |
| description | | description |
| "Information about a flooded link"; | | "Information about a flooded link"; |
| container odu-link-capabilities { | | container odu-link-capabilities { |
| description | | description |
| "ODU Link Capabilities"; | | "ODU Link Capabilities"; |
| uses ODU-LINK-CAPABILITIES; | | uses ODU-LINK-CAPABILITIES; |
| } | | } |
| leaf link-id { | | leaf link-id { |
| type uint16; | | type uint16; |
| description | | description |
| "The link's id"; | | "The link's id"; |
| } | | } |
| leaf interface-name { | | leaf interface-name { |
| type string; | | type string; |
| description | | description |
| "The link's interface name"; | | "The link's interface name"; |
| } | | } |
| leaf link-address { | | leaf link-address { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "The link's IPv4 address"; | | "The link's IPv4 address"; |
| } | | } |
| leaf subnet-type { | | leaf subnet-type { |
| type Igp-subnet; | | type Igp-subnet; |
| description | | description |
| "The link's subnet type"; | | "The link's subnet type"; |
| } | | } |
| leaf outgoing-interface-id { | | leaf outgoing-interface-id { |
| type uint32; | | type uint32; |
| description | | description |
| "The link's outgoing interface's id"; | | "The link's outgoing interface's id"; |
| } | | } |
| leaf is-designated-router { | | leaf is-designated-router { |
| type boolean; | | type boolean; |
| description | | description |
| "TRUE if the link belongs to a desig. router"; | | "TRUE if the link belongs to a desig. router"; |
| } | | } |
| leaf designated-router-igp-id { | | leaf designated-router-igp-id { |
| type string; | | type string; |
| description | | description |
| "IGP id of the designated router"; | | "IGP id of the designated router"; |
| } | | } |
| leaf neighbor-igp-id { | | leaf neighbor-igp-id { |
| type string; | | type string; |
| description | | description |
| "The neighbor's IGP id"; | | "The neighbor's IGP id"; |
| } | | } |
| leaf igp-neighbor-address { | | leaf igp-neighbor-address { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "The neighbor's ip address"; | | "The neighbor's ip address"; |
| } | | } |
| leaf incoming-interface-id { | | leaf incoming-interface-id { |
| type uint32; | | type uint32; |
| description | | description |
| "The link's incoming interface's id"; | | "The link's incoming interface's id"; |
| } | | } |
| leaf te-metric { | | leaf te-metric { |
| type uint32; | | type uint32; |
| description | | description |
| "The link's TE metric"; | | "The link's TE metric"; |
| } | | } |
| leaf igp-metric { | | leaf igp-metric { |
| type uint32; | | type uint32; |
| description | | description |
| "The link's IGP metric"; | | "The link's IGP metric"; |
| } | | } |
| leaf uni-link-delay { | | leaf uni-link-delay { |
| type uint32; | | type uint32; |
| description | | description |
| "Unidirectional Link Delay in micro-sec"; | | "Unidirectional Link Delay in micro-sec"; |
| } | | } |
| leaf bandwidth-units { | | leaf bandwidth-units { |
| type Bandwidth-unit-enum; | | type Bandwidth-unit-enum; |
| description | | description |
| "The link's bandwidth units"; | | "The link's bandwidth units"; |
| } | | } |
| leaf physical-bandwidth { | | leaf physical-bandwidth { |
| type uint32; | | type uint32; |
| description | | description |
| "The link's physical BW"; | | "The link's physical BW"; |
| } | | } |
| leaf bcm-id { | | leaf bcm-id { |
| type uint16; | | type uint16; |
| description | | description |
| "Bandwidth Constraints Model ID"; | | "Bandwidth Constraints Model ID"; |
| } | | } |
| leaf link-maximum-reservable-bandwidth { | | leaf link-maximum-reservable-bandwidth { |
| type uint32; | | type uint32; |
| description | | description |
| "The link's maximum reservable BW"; | | "The link's maximum reservable BW"; |
| } | | } |
| leaf reservable-pool0-bandwidth { | | leaf reservable-pool0-bandwidth { |
| type uint32; | | type uint32; |
| description | | description |
| "The link's reservable pool0 BW"; | | "The link's reservable pool0 BW"; |
| } | | } |
| leaf reservable-pool1-bandwidth { | | leaf reservable-pool1-bandwidth { |
| type uint32; | | type uint32; |
| description | | description |
| "The link's reservable pool1 BW"; | | "The link's reservable pool1 BW"; |
| } | | } |
| leaf is-receiving-reservable-bandwidth-enabled { | | leaf is-receiving-reservable-bandwidth-enabled { |
| type boolean; | | type boolean; |
| description | | description |
| "TRUE if receiving reservable BW is enabled"; | | "TRUE if receiving reservable BW is enabled"; |
| } | | } |
| leaf receiving-direction { | | leaf receiving-direction { |
| type Link-direction-enum; | | type Link-direction-enum; |
| description | | description |
| "Upstream or Downstream"; | | "Upstream or Downstream"; |
| } | | } |
| leaf is-transmitting-reservable-bandwidth-enabled { | | leaf is-transmitting-reservable-bandwidth-enabled { |
| type boolean; | | type boolean; |
| description | | description |
| "TRUE if transmitting reservable BW is enabled"; | | "TRUE if transmitting reservable BW is enabled"; |
| } | | } |
| leaf transmitting-direction { | | leaf transmitting-direction { |
| type Link-direction-enum; | | type Link-direction-enum; |
| description | | description |
| "Upstream or Downstream"; | | "Upstream or Downstream"; |
| } | | } |
| leaf affinity-attribute-flags { | | leaf affinity-attribute-flags { |
| type uint32; | | type uint32; |
| description | | description |
| "Deprecated"; | | "Deprecated"; |
| } | | } |
| list extended-affinity-attribute-flag { | | list extended-affinity-attribute-flag { |
| description | | description |
| "The link's extended affinity bits"; | | "The link's extended affinity bits"; |
| leaf entry { | | leaf entry { |
| type uint32; | | type uint32; |
| description | | description |
| "The link's extended affinity bits"; | | "The link's extended affinity bits"; |
| } | | } |
| } | | } |
| list shared-risk-link-group { | | list shared-risk-link-group { |
| description | | description |
| "The link's shared risk link groups"; | | "The link's shared risk link groups"; |
| uses MPLS-SRLG-INFO; | | uses MPLS-SRLG-INFO; |
| } | | } |
| list receiving-reservable-bandwidth { | | list receiving-reservable-bandwidth { |
| max-elements "8"; | | max-elements "8"; |
| description | | description |
| "Receiving reservable BW at each priority | | "Receiving reservable BW at each priority |
| level(priority 0 to priority 7)"; | | level(priority 0 to priority 7)"; |
| uses MPLS-LM-ADV-LINK-RESV-BW; | | uses MPLS-LM-ADV-LINK-RESV-BW; |
| } | | } |
| list transmitting-reservable-bandwidth { | | list transmitting-reservable-bandwidth { |
| max-elements "8"; | | max-elements "8"; |
| description | | description |
| "Transmitting reservable BW at each priority | | "Transmitting reservable BW at each priority |
| level (priority 0 to priority 7)"; | | level (priority 0 to priority 7)"; |
| uses MPLS-LM-ADV-LINK-RESV-BW; | | uses MPLS-LM-ADV-LINK-RESV-BW; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-LM-ADV-CONFIGURED-AREA { | | grouping MPLS-LM-ADV-CONFIGURED-AREA { |
| description | | description |
| "The information about an advertized area"; | | "The information about an advertized area"; |
| leaf igp-area-id { | | leaf igp-area-id { |
| type string; | | type string; |
| description | | description |
| "The area id"; | | "The area id"; |
| } | | } |
| leaf protocol { | | leaf protocol { |
| type Igp-protocol; | | type Igp-protocol; |
| description | | description |
| "The IGP protocol running over this area"; | | "The IGP protocol running over this area"; |
| } | | } |
| leaf system-id { | | leaf system-id { |
| type string; | | type string; |
| description | | description |
| "The node's system id"; | | "The node's system id"; |
| } | | } |
| leaf router-id { | | leaf router-id { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "The node's router ID"; | | "The node's router ID"; |
| } | | } |
| list flooded-link { | | list flooded-link { |
| description | | description |
| "The array of flooded links in this area"; | | "The array of flooded links in this area"; |
| uses MPLS-LM-ADV-FLOODED-LINK; | | uses MPLS-LM-ADV-FLOODED-LINK; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-LM-ADVERTISEMENT-INFO { | | grouping MPLS-LM-ADVERTISEMENT-INFO { |
| description | | description |
| "Information about all the advertized areas"; | | "Information about all the advertized areas"; |
| leaf flooding-status-message { | | leaf flooding-status-message { |
| type string; | | type string; |
| description | | description |
| "Flooding status: ready or reason"; | | "Flooding status: ready or reason"; |
| } | | } |
| leaf last-flooding-time { | | leaf last-flooding-time { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Time elapsed since last flooding in seconds"; | | "Time elapsed since last flooding in seconds"; |
| } | | } |
| leaf last-flooding-trigger { | | leaf last-flooding-trigger { |
| type Flooding-trigger; | | type Flooding-trigger; |
| description | | description |
| "Trigger for last flooding"; | | "Trigger for last flooding"; |
| } | | } |
| leaf next-flooding-time { | | leaf next-flooding-time { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Time remained for next flooding in seconds"; | | "Time remained for next flooding in seconds"; |
| } | | } |
| leaf ds-te-mode { | | leaf ds-te-mode { |
| type Rrr-dste-migration-mode; | | type Rrr-dste-migration-mode; |
| description | | description |
| "DS-TE Mode"; | | "DS-TE Mode"; |
| } | | } |
| list advertized-areas { | | list advertized-areas { |
| description | | description |
| "Advertising info for all the IGP areas"; | | "Advertising info for all the IGP areas"; |
| uses MPLS-LM-ADV-CONFIGURED-AREA; | | uses MPLS-LM-ADV-CONFIGURED-AREA; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-LM-PREEMPTED-LSP { | | grouping MPLS-LM-PREEMPTED-LSP { |
| description | | description |
| "Preempted LSP info"; | | "Preempted LSP info"; |
| leaf tunnel-id { | | leaf tunnel-id { |
| type uint16; | | type uint16; |
| description | | description |
| "Tunnel ID"; | | "Tunnel ID"; |
| } | | } |
| leaf lsp-id { | | leaf lsp-id { |
| type uint16; | | type uint16; |
| description | | description |
| "LSP ID"; | | "LSP ID"; |
| } | | } |
| leaf source-address { | | leaf source-address { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Source"; | | "Source"; |
| } | | } |
| leaf destination-address { | | leaf destination-address { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Destination"; | | "Destination"; |
| } | | } |
| leaf requested-bandwidth { | | leaf requested-bandwidth { |
| type uint64; | | type uint64; |
| description | | description |
| "The path's requested bandwidth"; | | "The path's requested bandwidth"; |
| } | | } |
| leaf setup-priority { | | leaf setup-priority { |
| type uint8; | | type uint8; |
| description | | description |
| "The path's setup priority"; | | "The path's setup priority"; |
| } | | } |
| leaf hold-priority { | | leaf hold-priority { |
| type uint8; | | type uint8; |
| description | | description |
| "The path's hold priority"; | | "The path's hold priority"; |
| } | | } |
| leaf bandwidth-type { | | leaf bandwidth-type { |
| type uint8; | | type uint8; |
| description | | description |
| "The path's bandwidth type; 0:BC0, 1:BC1, so on"; | | "The path's bandwidth type; 0:BC0, 1:BC1, so on"; |
| } | | } |
| leaf soft-preempted { | | leaf soft-preempted { |
| type boolean; | | type boolean; |
| description | | description |
| "TRUE is the preemption is a soft preemption"; | | "TRUE is the preemption is a soft preemption"; |
| } | | } |
| leaf soft-preemption-timeout { | | leaf soft-preemption-timeout { |
| type uint16; | | type uint16; |
| units "second"; | | units "second"; |
| description | | description |
| "If the soft preemption is underway, this value | | "If the soft preemption is underway, this value |
| indicates the number of seconds before hard | | indicates the number of seconds before hard |
| preemption is triggered"; | | preemption is triggered"; |
| } | | } |
| leaf bandwidth-preempted { | | leaf bandwidth-preempted { |
| type boolean; | | type boolean; |
| description | | description |
| "LSPs bandwidth is already preempted"; | | "LSPs bandwidth is already preempted"; |
| } | | } |
| leaf soft-preempted-fr-rrewrite { | | leaf soft-preempted-fr-rrewrite { |
| type boolean; | | type boolean; |
| description | | description |
| "FRR-rewrite is done during soft preemption"; | | "FRR-rewrite is done during soft preemption"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-LM-PREEMPTION-EVENT { | | grouping MPLS-LM-PREEMPTION-EVENT { |
| description | | description |
| "Preemption event info"; | | "Preemption event info"; |
| leaf tunnel-id { | | leaf tunnel-id { |
| type uint16; | | type uint16; |
| description | | description |
| "Tunnel ID"; | | "Tunnel ID"; |
| } | | } |
| leaf lsp-id { | | leaf lsp-id { |
| type uint16; | | type uint16; |
| description | | description |
| "LSP ID"; | | "LSP ID"; |
| } | | } |
| leaf source-address { | | leaf source-address { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Source"; | | "Source"; |
| } | | } |
| leaf destination-address { | | leaf destination-address { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Destination"; | | "Destination"; |
| } | | } |
| leaf requested-bandwidth { | | leaf requested-bandwidth { |
| type uint64; | | type uint64; |
| description | | description |
| "The path's requested bandwidth"; | | "The path's requested bandwidth"; |
| } | | } |
| leaf setup-priority { | | leaf setup-priority { |
| type uint8; | | type uint8; |
| description | | description |
| "The path's setup priority"; | | "The path's setup priority"; |
| } | | } |
| leaf hold-priority { | | leaf hold-priority { |
| type uint8; | | type uint8; |
| description | | description |
| "The path's hold priority"; | | "The path's hold priority"; |
| } | | } |
| leaf bandwidth-type { | | leaf bandwidth-type { |
| type uint8; | | type uint8; |
| description | | description |
| "The path's bandwidth type; 0:CT0, 1:CT1, so on"; | | "The path's bandwidth type; 0:CT0, 1:CT1, so on"; |
| } | | } |
| leaf old-bandwidth-bc0 { | | leaf old-bandwidth-bc0 { |
| type uint64; | | type uint64; |
| description | | description |
| "Old BW for BC0"; | | "Old BW for BC0"; |
| } | | } |
| leaf old-bandwidth-bc1 { | | leaf old-bandwidth-bc1 { |
| type uint64; | | type uint64; |
| description | | description |
| "Old BW for BC1"; | | "Old BW for BC1"; |
| } | | } |
| leaf new-bandwidth-bc0 { | | leaf new-bandwidth-bc0 { |
| type uint64; | | type uint64; |
| description | | description |
| "New BW for BC0"; | | "New BW for BC0"; |
| } | | } |
| leaf new-bandwidth-bc1 { | | leaf new-bandwidth-bc1 { |
| type uint64; | | type uint64; |
| description | | description |
| "New BW for BC1"; | | "New BW for BC1"; |
| } | | } |
| leaf bandwidth-overshoot0 { | | leaf bandwidth-overshoot0 { |
| type uint64; | | type uint64; |
| description | | description |
| "BW Overshoot for BC0"; | | "BW Overshoot for BC0"; |
| } | | } |
| leaf bandwidth-overshoot1 { | | leaf bandwidth-overshoot1 { |
| type uint64; | | type uint64; |
| description | | description |
| "BW Overshoot for BC1"; | | "BW Overshoot for BC1"; |
| } | | } |
| leaf interface-name { | | leaf interface-name { |
| type string; | | type string; |
| description | | description |
| "Interface name"; | | "Interface name"; |
| } | | } |
| leaf event-time { | | leaf event-time { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Event time; seconds elapsed since January 1, | | "Event time; seconds elapsed since January 1, |
| 1970"; | | 1970"; |
| } | | } |
| leaf ls-ps { | | leaf ls-ps { |
| type uint16; | | type uint16; |
| description | | description |
| "Number of LSPs (not all may be present in the | | "Number of LSPs (not all may be present in the |
| list)"; | | list)"; |
| } | | } |
| leaf soft-preempted-ls-ps { | | leaf soft-preempted-ls-ps { |
| type uint16; | | type uint16; |
| description | | description |
| "Number of LSPs softly preempted"; | | "Number of LSPs softly preempted"; |
| } | | } |
| leaf soft-preempted-ls-ps-fr-rrewrite { | | leaf soft-preempted-ls-ps-fr-rrewrite { |
| type uint16; | | type uint16; |
| description | | description |
| "Number of LSPs softly preempted with traffic | | "Number of LSPs softly preempted with traffic |
| switched to backup"; | | switched to backup"; |
| } | | } |
| leaf hard-preempted-ls-ps { | | leaf hard-preempted-ls-ps { |
| type uint16; | | type uint16; |
| description | | description |
| "Number of LSPs hardly preempted"; | | "Number of LSPs hardly preempted"; |
| } | | } |
| leaf total-preempted-bandwidth-bc0 { | | leaf total-preempted-bandwidth-bc0 { |
| type uint64; | | type uint64; |
| description | | description |
| "Total amount of preempted class 0 bandwidth"; | | "Total amount of preempted class 0 bandwidth"; |
| } | | } |
| leaf total-preempted-bandwidth-bc1 { | | leaf total-preempted-bandwidth-bc1 { |
| type uint64; | | type uint64; |
| description | | description |
| "Total amount of preempted class 1 bandwidth"; | | "Total amount of preempted class 1 bandwidth"; |
| } | | } |
| leaf softly-preempted-bandwidth-bc0 { | | leaf softly-preempted-bandwidth-bc0 { |
| type uint64; | | type uint64; |
| description | | description |
| "Amount of softly preempted class 0 bandwidth"; | | "Amount of softly preempted class 0 bandwidth"; |
| } | | } |
| leaf softly-preempted-bandwidth-bc1 { | | leaf softly-preempted-bandwidth-bc1 { |
| type uint64; | | type uint64; |
| description | | description |
| "Amount of softly preempted class 1 bandwidth"; | | "Amount of softly preempted class 1 bandwidth"; |
| } | | } |
| leaf soft-preempted-fr-rrewrite-bandwidth-bc0 { | | leaf soft-preempted-fr-rrewrite-bandwidth-bc0 { |
| type uint64; | | type uint64; |
| description | | description |
| "Amount of softly preempted FRR RW class 0 | | "Amount of softly preempted FRR RW class 0 |
| bandwidth"; | | bandwidth"; |
| } | | } |
| leaf soft-preempted-fr-rrewrite-bandwidth-bc1 { | | leaf soft-preempted-fr-rrewrite-bandwidth-bc1 { |
| type uint64; | | type uint64; |
| description | | description |
| "Amount of softly preempted FRR RW class 1 | | "Amount of softly preempted FRR RW class 1 |
| bandwidth"; | | bandwidth"; |
| } | | } |
| leaf hard-preempted-bandwidth-bc0 { | | leaf hard-preempted-bandwidth-bc0 { |
| type uint64; | | type uint64; |
| description | | description |
| "Amount of hard preempted class 0 bandwidth"; | | "Amount of hard preempted class 0 bandwidth"; |
| } | | } |
| leaf hard-preempted-bandwidth-bc1 { | | leaf hard-preempted-bandwidth-bc1 { |
| type uint64; | | type uint64; |
| description | | description |
| "Amount of hard preempted class 1 bandwidth"; | | "Amount of hard preempted class 1 bandwidth"; |
| } | | } |
| leaf tunnels { | | leaf tunnels { |
| type uint16; | | type uint16; |
| description | | description |
| "Number of Tunnels"; | | "Number of Tunnels"; |
| } | | } |
| leaf soft-preempted-tunnels { | | leaf soft-preempted-tunnels { |
| type uint16; | | type uint16; |
| description | | description |
| "Number of Tunnels softly preempted"; | | "Number of Tunnels softly preempted"; |
| } | | } |
| leaf soft-preempted-tunnels-fr-rrewrite { | | leaf soft-preempted-tunnels-fr-rrewrite { |
| type uint16; | | type uint16; |
| description | | description |
| "Number of Tunnels softly preempted with traffic | | "Number of Tunnels softly preempted with traffic |
| switched to backup"; | | switched to backup"; |
| } | | } |
| leaf hard-preempted-tunnels { | | leaf hard-preempted-tunnels { |
| type uint16; | | type uint16; |
| description | | description |
| "Number of Tunnels hardly preempted"; | | "Number of Tunnels hardly preempted"; |
| } | | } |
| list lsp { | | list lsp { |
| description | | description |
| "List of preempted LSPs"; | | "List of preempted LSPs"; |
| uses MPLS-LM-PREEMPTED-LSP; | | uses MPLS-LM-PREEMPTED-LSP; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-LM-IGP-NBR-INFO { | | grouping MPLS-LM-IGP-NBR-INFO { |
| description | | description |
| "Neighbor information"; | | "Neighbor information"; |
| leaf interface-name { | | leaf interface-name { |
| type string; | | type string; |
| description | | description |
| "The interface on which this neighbor is | | "The interface on which this neighbor is |
| discovered"; | | discovered"; |
| } | | } |
| leaf neighbor-id { | | leaf neighbor-id { |
| type string; | | type string; |
| description | | description |
| "The neighbor's id"; | | "The neighbor's id"; |
| } | | } |
| leaf area-id { | | leaf area-id { |
| type string; | | type string; |
| description | | description |
| "The area id"; | | "The area id"; |
| } | | } |
| leaf neighbor-address { | | leaf neighbor-address { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "The neighbor's IP address"; | | "The neighbor's IP address"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-LM-IGP-NBRS-LINK-INFO { | | grouping MPLS-LM-IGP-NBRS-LINK-INFO { |
| description | | description |
| "Neighbor information based on the link"; | | "Neighbor information based on the link"; |
| list neighbor { | | list neighbor { |
| description | | description |
| "Neighbors of the specified link id"; | | "Neighbors of the specified link id"; |
| uses MPLS-LM-IGP-NBR-INFO; | | uses MPLS-LM-IGP-NBR-INFO; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-AFFINITY-MAP-BAG { | | grouping MPLS-TE-AFFINITY-MAP-BAG { |
| description | | description |
| "A set of affinity maps"; | | "A set of affinity maps"; |
| list affinity-map-array { | | list affinity-map-array { |
| description | | description |
| "Affinity map array"; | | "Affinity map array"; |
| uses MPLS-TE-AFFINITY-MAP-INFO; | | uses MPLS-TE-AFFINITY-MAP-INFO; |
| } | | } |
| } | | } |
| | | |
| grouping TE-AUTO-TUN-EXP-PATH-HOP { | | grouping TE-AUTO-TUN-EXP-PATH-HOP { |
| description | | description |
| "Auto Tunnel Explicit Path Hop"; | | "Auto Tunnel Explicit Path Hop"; |
| leaf hop-type { | | leaf hop-type { |
| type Te-auto-tun-exp-path-hop; | | type Te-auto-tun-exp-path-hop; |
| description | | description |
| "Hop Type"; | | "Hop Type"; |
| } | | } |
| leaf ipv4-address { | | leaf ipv4-address { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "IPv4 Address"; | | "IPv4 Address"; |
| } | | } |
| leaf mpls-label { | | leaf mpls-label { |
| type uint32; | | type uint32; |
| description | | description |
| "MPLS Label"; | | "MPLS Label"; |
| } | | } |
| } | | } |
| | | |
| grouping TE-AUTO-TUN-REQ-EXP-PATH-TUN-INFO { | | grouping TE-AUTO-TUN-REQ-EXP-PATH-TUN-INFO { |
| description | | description |
| "Auto tunnel request explicit path tunnel info"; | | "Auto tunnel request explicit path tunnel info"; |
| leaf tunnel-id { | | leaf tunnel-id { |
| type uint32; | | type uint32; |
| description | | description |
| "Tunnel ID"; | | "Tunnel ID"; |
| } | | } |
| leaf tunnel-up { | | leaf tunnel-up { |
| type boolean; | | type boolean; |
| description | | description |
| "Tunnel Up"; | | "Tunnel Up"; |
| } | | } |
| leaf ipv6-caps { | | leaf ipv6-caps { |
| type boolean; | | type boolean; |
| description | | description |
| "IPv6 Capsulation"; | | "IPv6 Capsulation"; |
| } | | } |
| } | | } |
| | | |
| grouping TE-AUTO-TUN-REQ-EXP-PATH { | | grouping TE-AUTO-TUN-REQ-EXP-PATH { |
| description | | description |
| "Auto Tunnel Explicit Path"; | | "Auto Tunnel Explicit Path"; |
| container tunnel-info { | | container tunnel-info { |
| description | | description |
| "Auto tunnel info"; | | "Auto tunnel info"; |
| uses TE-AUTO-TUN-REQ-EXP-PATH-TUN-INFO; | | uses TE-AUTO-TUN-REQ-EXP-PATH-TUN-INFO; |
| } | | } |
| leaf context-id { | | leaf context-id { |
| type uint32; | | type uint32; |
| description | | description |
| "Explicit Path Context ID"; | | "Explicit Path Context ID"; |
| } | | } |
| leaf path-weight { | | leaf path-weight { |
| type uint32; | | type uint32; |
| description | | description |
| "Path Weight"; | | "Path Weight"; |
| } | | } |
| leaf is-stale { | | leaf is-stale { |
| type boolean; | | type boolean; |
| description | | description |
| "Is Stale"; | | "Is Stale"; |
| } | | } |
| leaf is-synced { | | leaf is-synced { |
| type boolean; | | type boolean; |
| description | | description |
| "Is Synced"; | | "Is Synced"; |
| } | | } |
| leaf programmed-in-fib { | | leaf programmed-in-fib { |
| type boolean; | | type boolean; |
| description | | description |
| "Programmed in FIB"; | | "Programmed in FIB"; |
| } | | } |
| list hops { | | list hops { |
| description | | description |
| "Path Hops"; | | "Path Hops"; |
| uses TE-AUTO-TUN-EXP-PATH-HOP; | | uses TE-AUTO-TUN-EXP-PATH-HOP; |
| } | | } |
| } | | } |
| | | |
| grouping TE-END-POINT { | | grouping TE-END-POINT { |
| description | | description |
| "TE End Point"; | | "TE End Point"; |
| leaf address-family-type { | | leaf address-family-type { |
| type Mpls-te-afi; | | type Mpls-te-afi; |
| description | | description |
| "AddressFamilyType"; | | "AddressFamilyType"; |
| } | | } |
| leaf ipv4-address { | | leaf ipv4-address { |
| when "../address-family-type = 'ipv4-unicast'" { | | when "../address-family-type = 'ipv4-unicast'" { |
| description | | description |
| "../AddressFamilyType = 'IPv4Unicast'"; | | "../AddressFamilyType = 'IPv4Unicast'"; |
| } | | } |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "IPv4 Address"; | | "IPv4 Address"; |
| } | | } |
| leaf ipv6-address { | | leaf ipv6-address { |
| when "../address-family-type = 'ipv6-unicast'" { | | when "../address-family-type = 'ipv6-unicast'" { |
| description | | description |
| "../AddressFamilyType = 'IPv6Unicast'"; | | "../AddressFamilyType = 'IPv6Unicast'"; |
| } | | } |
| type In-addr-ipv6; | | type In-addr-ipv6; |
| description | | description |
| "IPv6 Address"; | | "IPv6 Address"; |
| } | | } |
| } | | } |
| | | |
| grouping TE-SERVICE-SR-POLICY { | | grouping TE-SERVICE-SR-POLICY { |
| description | | description |
| "Auto Tunnel Request Context"; | | "Auto Tunnel Request Context"; |
| container end-point-xr { | | container end-point-xr { |
| description | | description |
| "End Point"; | | "End Point"; |
| uses TE-END-POINT; | | uses TE-END-POINT; |
| } | | } |
| leaf sr-policy-id { | | leaf sr-policy-id { |
| type uint32; | | type uint32; |
| description | | description |
| "SR Policy ID"; | | "SR Policy ID"; |
| } | | } |
| leaf policy-active { | | leaf policy-active { |
| type boolean; | | type boolean; |
| description | | description |
| "Policy Active"; | | "Policy Active"; |
| } | | } |
| leaf client-id-xr { | | leaf client-id-xr { |
| type uint32; | | type uint32; |
| description | | description |
| "Client ID"; | | "Client ID"; |
| } | | } |
| leaf client-name { | | leaf client-name { |
| type string; | | type string; |
| description | | description |
| "Client Name"; | | "Client Name"; |
| } | | } |
| leaf color-xr { | | leaf color-xr { |
| type uint32; | | type uint32; |
| description | | description |
| "Color"; | | "Color"; |
| } | | } |
| leaf distinguisher-xr { | | leaf distinguisher-xr { |
| type uint32; | | type uint32; |
| description | | description |
| "SR Policy Distinguisher value"; | | "SR Policy Distinguisher value"; |
| } | | } |
| leaf ipv6-caps { | | leaf ipv6-caps { |
| type boolean; | | type boolean; |
| description | | description |
| "IPv6 Capsulation"; | | "IPv6 Capsulation"; |
| } | | } |
| leaf binding-sid-context-id { | | leaf binding-sid-context-id { |
| type uint32; | | type uint32; |
| description | | description |
| "Binding SID Context ID"; | | "Binding SID Context ID"; |
| } | | } |
| leaf requested-binding-sid { | | leaf requested-binding-sid { |
| type uint32; | | type uint32; |
| description | | description |
| "Requested Binding SID"; | | "Requested Binding SID"; |
| } | | } |
| leaf binding-sid-request-pending { | | leaf binding-sid-request-pending { |
| type boolean; | | type boolean; |
| description | | description |
| "Binding SID Request Pending"; | | "Binding SID Request Pending"; |
| } | | } |
| leaf allocated-binding-sid { | | leaf allocated-binding-sid { |
| type uint32; | | type uint32; |
| description | | description |
| "Allocated Binding SID"; | | "Allocated Binding SID"; |
| } | | } |
| leaf rewrite-request-pending { | | leaf rewrite-request-pending { |
| type boolean; | | type boolean; |
| description | | description |
| "Rewrite Requeste Pending"; | | "Rewrite Requeste Pending"; |
| } | | } |
| leaf rewrite-done { | | leaf rewrite-done { |
| type boolean; | | type boolean; |
| description | | description |
| "Rewrite Done"; | | "Rewrite Done"; |
| } | | } |
| leaf is-stale { | | leaf is-stale { |
| type boolean; | | type boolean; |
| description | | description |
| "Is Stale"; | | "Is Stale"; |
| } | | } |
| leaf is-synced { | | leaf is-synced { |
| type boolean; | | type boolean; |
| description | | description |
| "Is Synced"; | | "Is Synced"; |
| } | | } |
| leaf notify-time { | | leaf notify-time { |
| type uint32; | | type uint32; |
| description | | description |
| "Notify Time"; | | "Notify Time"; |
| } | | } |
| leaf notify-state-is-active { | | leaf notify-state-is-active { |
| type boolean; | | type boolean; |
| description | | description |
| "Notify State Is Active"; | | "Notify State Is Active"; |
| } | | } |
| leaf creation-time { | | leaf creation-time { |
| type uint64; | | type uint64; |
| units "nanosecond"; | | units "nanosecond"; |
| description | | description |
| "SR policy structure creation timestamp | | "SR policy structure creation timestamp |
| (clocktime in nsecs)"; | | (clocktime in nsecs)"; |
| } | | } |
| list explicit-path { | | list explicit-path { |
| description | | description |
| "Explicit Paths"; | | "Explicit Paths"; |
| uses TE-AUTO-TUN-REQ-EXP-PATH; | | uses TE-AUTO-TUN-REQ-EXP-PATH; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-BFD-SUMMARY { | | grouping MPLS-TE-BFD-SUMMARY { |
| description | | description |
| "TE BFD Summary Info"; | | "TE BFD Summary Info"; |
| leaf tunnel-count-total { | | leaf tunnel-count-total { |
| type uint16; | | type uint16; |
| description | | description |
| "Total number of tunnel interface"; | | "Total number of tunnel interface"; |
| } | | } |
| leaf tunnel-count-bfd-enabled { | | leaf tunnel-count-bfd-enabled { |
| type uint16; | | type uint16; |
| description | | description |
| "Number of tunnel interface with BFD enabled"; | | "Number of tunnel interface with BFD enabled"; |
| } | | } |
| leaf tunnel-count-session-up { | | leaf tunnel-count-session-up { |
| type uint16; | | type uint16; |
| description | | description |
| "Number of tunnel with BFD session in up state"; | | "Number of tunnel with BFD session in up state"; |
| } | | } |
| leaf tunnel-count-sbfd-enabled { | | leaf tunnel-count-sbfd-enabled { |
| type uint16; | | type uint16; |
| description | | description |
| "Number of tunnel interface with SBFD enabled"; | | "Number of tunnel interface with SBFD enabled"; |
| } | | } |
| leaf tunnel-count-sbfd-session-up { | | leaf tunnel-count-sbfd-session-up { |
| type uint16; | | type uint16; |
| description | | description |
| "Number of tunnel with SBFD session in up state"; | | "Number of tunnel with SBFD session in up state"; |
| } | | } |
| leaf head-lsp-count-session-created { | | leaf head-lsp-count-session-created { |
| type uint16; | | type uint16; |
| description | | description |
| "Number of head end LSP with BFD session created"; | | "Number of head end LSP with BFD session created"; |
| } | | } |
| leaf head-lsp-count-up { | | leaf head-lsp-count-up { |
| type uint16; | | type uint16; |
| description | | description |
| "Number of head end LSP with BFD session in up | | "Number of head end LSP with BFD session in up |
| state"; | | state"; |
| } | | } |
| leaf tail-lsp-count-session-created { | | leaf tail-lsp-count-session-created { |
| type uint16; | | type uint16; |
| description | | description |
| "Number of tail end LSP with BFD session created"; | | "Number of tail end LSP with BFD session created"; |
| } | | } |
| leaf tail-lsp-count-session-up { | | leaf tail-lsp-count-session-up { |
| type uint16; | | type uint16; |
| description | | description |
| "Number of tail end LSP with BFD session in up | | "Number of tail end LSP with BFD session in up |
| state"; | | state"; |
| } | | } |
| leaf head-lsp-count-sbfd-session-created { | | leaf head-lsp-count-sbfd-session-created { |
| type uint16; | | type uint16; |
| description | | description |
| "Number of head end LSP with SBFD session created"; | | "Number of head end LSP with SBFD session created"; |
| } | | } |
| leaf head-lsp-count-sbfd-up { | | leaf head-lsp-count-sbfd-up { |
| type uint16; | | type uint16; |
| description | | description |
| "Number of head end LSP with SBFD session in up | | "Number of head end LSP with SBFD session in up |
| state"; | | state"; |
| } | | } |
| leaf link-count-bfd-enabled { | | leaf link-count-bfd-enabled { |
| type uint16; | | type uint16; |
| description | | description |
| "Number of link with BFD enabled"; | | "Number of link with BFD enabled"; |
| } | | } |
| leaf link-count-session-created { | | leaf link-count-session-created { |
| type uint16; | | type uint16; |
| description | | description |
| "Number of link with BFD session created"; | | "Number of link with BFD session created"; |
| } | | } |
| leaf link-count-session-up { | | leaf link-count-session-up { |
| type uint16; | | type uint16; |
| description | | description |
| "Number of link with BFD session in state Up"; | | "Number of link with BFD session in state Up"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-TAIL-BFD-LSP-INFO { | | grouping MPLS-TE-TAIL-BFD-LSP-INFO { |
| description | | description |
| "TE Tail End BFDOverLSP Info"; | | "TE Tail End BFDOverLSP Info"; |
| container lsp-fec { | | container lsp-fec { |
| description | | description |
| "FEC for the LSP"; | | "FEC for the LSP"; |
| uses TE-LSP-FEC; | | uses TE-LSP-FEC; |
| } | | } |
| leaf signaled-name { | | leaf signaled-name { |
| type string; | | type string; |
| description | | description |
| "Signaled Name"; | | "Signaled Name"; |
| } | | } |
| leaf bfd-session-state { | | leaf bfd-session-state { |
| type Te-bfd-lsp-session-state; | | type Te-bfd-lsp-session-state; |
| description | | description |
| "BFD Session State"; | | "BFD Session State"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-HEAD-BFD-LSP-INFO { | | grouping MPLS-TE-HEAD-BFD-LSP-INFO { |
| description | | description |
| "TE Head End BFDOverLSP Info"; | | "TE Head End BFDOverLSP Info"; |
| leaf lsp-id { | | leaf lsp-id { |
| type uint16; | | type uint16; |
| description | | description |
| "LSP ID"; | | "LSP ID"; |
| } | | } |
| leaf bfd-session-state { | | leaf bfd-session-state { |
| type Te-bfd-lsp-session-state; | | type Te-bfd-lsp-session-state; |
| description | | description |
| "BFD Session State"; | | "BFD Session State"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-HEAD-BFD-VIF-INFO { | | grouping MPLS-TE-HEAD-BFD-VIF-INFO { |
| description | | description |
| "TE Head End Tunnel BFD Info"; | | "TE Head End Tunnel BFD Info"; |
| container current-lspbfd-info { | | container current-lspbfd-info { |
| description | | description |
| "Current LSP BFD Info"; | | "Current LSP BFD Info"; |
| uses MPLS-TE-HEAD-BFD-LSP-INFO; | | uses MPLS-TE-HEAD-BFD-LSP-INFO; |
| } | | } |
| container standby-lspbfd-info { | | container standby-lspbfd-info { |
| description | | description |
| "Standby LSP BFD Info"; | | "Standby LSP BFD Info"; |
| uses MPLS-TE-HEAD-BFD-LSP-INFO; | | uses MPLS-TE-HEAD-BFD-LSP-INFO; |
| } | | } |
| container reoptimized-lspbfd-info { | | container reoptimized-lspbfd-info { |
| description | | description |
| "Reoptimized LSP BFD Info"; | | "Reoptimized LSP BFD Info"; |
| uses MPLS-TE-HEAD-BFD-LSP-INFO; | | uses MPLS-TE-HEAD-BFD-LSP-INFO; |
| } | | } |
| leaf tunnel-name-xr { | | leaf tunnel-name-xr { |
| type string; | | type string; |
| description | | description |
| "Tunnel name"; | | "Tunnel name"; |
| } | | } |
| leaf destination-address { | | leaf destination-address { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Destination Address"; | | "Destination Address"; |
| } | | } |
| leaf lspbfd-type { | | leaf lspbfd-type { |
| type Te-vif-bfd; | | type Te-vif-bfd; |
| description | | description |
| "LSP BFD type"; | | "LSP BFD type"; |
| } | | } |
| } | | } |
| | | |
| grouping TE-LSP-OOR-STATS { | | grouping TE-LSP-OOR-STATS { |
| description | | description |
| "LSP OOR statistics"; | | "LSP OOR statistics"; |
| leaf transitions { | | leaf transitions { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of transitions to this state"; | | "Number of transitions to this state"; |
| } | | } |
| leaf rejected-ls-ps-number { | | leaf rejected-ls-ps-number { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of LSPs that were rejected in this state"; | | "Number of LSPs that were rejected in this state"; |
| } | | } |
| leaf accepted-ls-ps-number { | | leaf accepted-ls-ps-number { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of LSPs that were accepted in this state"; | | "Number of LSPs that were accepted in this state"; |
| } | | } |
| leaf accepted-reopt-ls-ps-number { | | leaf accepted-reopt-ls-ps-number { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of Reoptimize LSPs that were accepted in | | "Number of Reoptimize LSPs that were accepted in |
| this state"; | | this state"; |
| } | | } |
| leaf rejected-reopt-ls-ps-number { | | leaf rejected-reopt-ls-ps-number { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of Reoptimize LSPs that were rejected in | | "Number of Reoptimize LSPs that were rejected in |
| this state"; | | this state"; |
| } | | } |
| } | | } |
| | | |
| grouping TE-LSP-OOR-STATE-INFO { | | grouping TE-LSP-OOR-STATE-INFO { |
| description | | description |
| "LSP OOR State Information"; | | "LSP OOR State Information"; |
| container statistics { | | container statistics { |
| description | | description |
| "LSP OOR Statistics"; | | "LSP OOR Statistics"; |
| uses TE-LSP-OOR-STATS; | | uses TE-LSP-OOR-STATS; |
| } | | } |
| leaf lsp-oor-state { | | leaf lsp-oor-state { |
| type Lsp-oor-state; | | type Lsp-oor-state; |
| description | | description |
| "The LSP-OOR state that this information belongs | | "The LSP-OOR state that this information belongs |
| to"; | | to"; |
| } | | } |
| leaf threshold-transit-all { | | leaf threshold-transit-all { |
| type uint32; | | type uint32; |
| description | | description |
| "The number of transit LSPs that triggers OOR | | "The number of transit LSPs that triggers OOR |
| state transition"; | | state transition"; |
| } | | } |
| leaf threshold-transit-unprotected { | | leaf threshold-transit-unprotected { |
| type uint32; | | type uint32; |
| description | | description |
| "The number of unprotected transit LSPs that | | "The number of unprotected transit LSPs that |
| triggers OOR state transition"; | | triggers OOR state transition"; |
| } | | } |
| leaf te-metric-penalty { | | leaf te-metric-penalty { |
| type uint32; | | type uint32; |
| description | | description |
| "The TE metric penalty when the link is in this | | "The TE metric penalty when the link is in this |
| LSP OOR state"; | | LSP OOR state"; |
| } | | } |
| leaf available-bw-percentage { | | leaf available-bw-percentage { |
| type uint32; | | type uint32; |
| units "percentage"; | | units "percentage"; |
| description | | description |
| "The flooded percentage of available bandwidth | | "The flooded percentage of available bandwidth |
| advertized when the link is in this LSP OOR | | advertized when the link is in this LSP OOR |
| state"; | | state"; |
| } | | } |
| leaf transition-duration { | | leaf transition-duration { |
| type uint32; | | type uint32; |
| units "minute"; | | units "minute"; |
| description | | description |
| "Recovery in minutes after the green LSP OOR | | "Recovery in minutes after the green LSP OOR |
| state is entered."; | | state is entered."; |
| } | | } |
| leaf minimum-lsp-bandwidth { | | leaf minimum-lsp-bandwidth { |
| type uint32; | | type uint32; |
| description | | description |
| "Minimum LSP bandwidth so the LSP is admitted | | "Minimum LSP bandwidth so the LSP is admitted |
| when the link is in this LSP OOR state"; | | when the link is in this LSP OOR state"; |
| } | | } |
| leaf accept-reopt { | | leaf accept-reopt { |
| type boolean; | | type boolean; |
| description | | description |
| "Make-before-break is allowed for LSPs | | "Make-before-break is allowed for LSPs |
| reoptimizing over the same link in the LSP OOR | | reoptimizing over the same link in the LSP OOR |
| state"; | | state"; |
| } | | } |
| } | | } |
| | | |
| grouping TE-LSP-OOR-INFO { | | grouping TE-LSP-OOR-INFO { |
| description | | description |
| "LSP OOR parameters for MPLS-TE"; | | "LSP OOR parameters for MPLS-TE"; |
| leaf transit-lsp-total-count { | | leaf transit-lsp-total-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of all transit LSPs on the router"; | | "Number of all transit LSPs on the router"; |
| } | | } |
| leaf transit-lsp-unprotected-count { | | leaf transit-lsp-unprotected-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of unprotected transit LSPs on the router"; | | "Number of unprotected transit LSPs on the router"; |
| } | | } |
| leaf lsp-oor-state { | | leaf lsp-oor-state { |
| type Lsp-oor-state; | | type Lsp-oor-state; |
| description | | description |
| "The current LSP OOR state"; | | "The current LSP OOR state"; |
| } | | } |
| leaf lsp-oor-timestamp { | | leaf lsp-oor-timestamp { |
| type uint32; | | type uint32; |
| description | | description |
| "Timestamp when the OOR state last changed"; | | "Timestamp when the OOR state last changed"; |
| } | | } |
| leaf lsp-oor-green-recovery-time { | | leaf lsp-oor-green-recovery-time { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Time Remaining in Green Recovery State (seconds)"; | | "Time Remaining in Green Recovery State (seconds)"; |
| } | | } |
| list lsp-oor-state-xr { | | list lsp-oor-state-xr { |
| max-elements "3"; | | max-elements "3"; |
| description | | description |
| "Array of LSP OOR info per state"; | | "Array of LSP OOR info per state"; |
| uses TE-LSP-OOR-STATE-INFO; | | uses TE-LSP-OOR-STATE-INFO; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-SR-S2L-PATH-BAG { | | grouping MPLS-TE-SR-S2L-PATH-BAG { |
| description | | description |
| "Segment-Routing S2L path"; | | "Segment-Routing S2L path"; |
| leaf is-primary { | | leaf is-primary { |
| type boolean; | | type boolean; |
| description | | description |
| "True if path is primary"; | | "True if path is primary"; |
| } | | } |
| leaf is-backup { | | leaf is-backup { |
| type boolean; | | type boolean; |
| description | | description |
| "True if path is backup"; | | "True if path is backup"; |
| } | | } |
| leaf outgoing-interface { | | leaf outgoing-interface { |
| type string; | | type string; |
| description | | description |
| "Outgoing Interface Name"; | | "Outgoing Interface Name"; |
| } | | } |
| leaf path-id { | | leaf path-id { |
| type uint32; | | type uint32; |
| description | | description |
| "Path Identifier"; | | "Path Identifier"; |
| } | | } |
| leaf backup-path-id { | | leaf backup-path-id { |
| type uint32; | | type uint32; |
| description | | description |
| "Backup Path Identifier"; | | "Backup Path Identifier"; |
| } | | } |
| leaf next-hop { | | leaf next-hop { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Next hop"; | | "Next hop"; |
| } | | } |
| list outgoing-labels-stack { | | list outgoing-labels-stack { |
| description | | description |
| "Outgoing Labels Stack"; | | "Outgoing Labels Stack"; |
| leaf entry { | | leaf entry { |
| type uint32; | | type uint32; |
| description | | description |
| "Outgoing Labels Stack"; | | "Outgoing Labels Stack"; |
| } | | } |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-S2L-FORWARDING-S2L-ID-BAG { | | grouping MPLS-TE-S2L-FORWARDING-S2L-ID-BAG { |
| description | | description |
| "S2L Forwarding identifiers"; | | "S2L Forwarding identifiers"; |
| leaf destination-address { | | leaf destination-address { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Destination"; | | "Destination"; |
| } | | } |
| leaf sub-group-id { | | leaf sub-group-id { |
| type uint16; | | type uint16; |
| description | | description |
| "S2L Sub-Group ID"; | | "S2L Sub-Group ID"; |
| } | | } |
| leaf sub-group-original-id { | | leaf sub-group-original-id { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "S2L Sub-Group Originator ID"; | | "S2L Sub-Group Originator ID"; |
| } | | } |
| } | | } |
| | | |
| grouping TE-S2L-OUTPUT-RW-FIELDS-BAG { | | grouping TE-S2L-OUTPUT-RW-FIELDS-BAG { |
| description | | description |
| "An entry of output label rewrite data"; | | "An entry of output label rewrite data"; |
| container primary-s2l { | | container primary-s2l { |
| description | | description |
| "Properties of the S2L rewrite"; | | "Properties of the S2L rewrite"; |
| uses TE-S2L-OUTPUT-RW-OUTPUT-INFO-BAG; | | uses TE-S2L-OUTPUT-RW-OUTPUT-INFO-BAG; |
| } | | } |
| container backup-tunnel-rewrite { | | container backup-tunnel-rewrite { |
| description | | description |
| "Properties of the S2L's backup tunnel rewrite"; | | "Properties of the S2L's backup tunnel rewrite"; |
| uses TE-S2L-OUTPUT-RW-OUTPUT-INFO-BAG; | | uses TE-S2L-OUTPUT-RW-OUTPUT-INFO-BAG; |
| } | | } |
| leaf timestamp { | | leaf timestamp { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Time stamp of the entry (secs since 1/1/70)"; | | "Time stamp of the entry (secs since 1/1/70)"; |
| } | | } |
| leaf out-rewrite-role { | | leaf out-rewrite-role { |
| type Mpls-te-tunnel-role; | | type Mpls-te-tunnel-role; |
| description | | description |
| "Role of the associated S2L"; | | "Role of the associated S2L"; |
| } | | } |
| leaf label { | | leaf label { |
| type uint32; | | type uint32; |
| description | | description |
| "Local label of the rewrite"; | | "Local label of the rewrite"; |
| } | | } |
| leaf backup-active { | | leaf backup-active { |
| type boolean; | | type boolean; |
| description | | description |
| "Backup is active"; | | "Backup is active"; |
| } | | } |
| leaf s2l-source { | | leaf s2l-source { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Source of the S2L"; | | "Source of the S2L"; |
| } | | } |
| leaf explicit-null { | | leaf explicit-null { |
| type Te-s2l-output-rw-explicit-null; | | type Te-s2l-output-rw-explicit-null; |
| description | | description |
| "Imposition of explicit NULL"; | | "Imposition of explicit NULL"; |
| } | | } |
| leaf protocol-transported { | | leaf protocol-transported { |
| type uint16; | | type uint16; |
| description | | description |
| "Protocol transported in the S2L"; | | "Protocol transported in the S2L"; |
| } | | } |
| } | | } |
| | | |
| grouping TE-S2L-OUTPUT-RW-FEC-SUBFAMILY-BAG { | | grouping TE-S2L-OUTPUT-RW-FEC-SUBFAMILY-BAG { |
| description | | description |
| "LMRIB S2L Output label rewrite FEC subfamily"; | | "LMRIB S2L Output label rewrite FEC subfamily"; |
| container lsp-fec { | | container lsp-fec { |
| description | | description |
| "LSP FEC"; | | "LSP FEC"; |
| uses TE-LSP-FEC; | | uses TE-LSP-FEC; |
| } | | } |
| leaf next-hop-address { | | leaf next-hop-address { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Next hop address"; | | "Next hop address"; |
| } | | } |
| leaf previous-hop-address { | | leaf previous-hop-address { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Previous hop address"; | | "Previous hop address"; |
| } | | } |
| leaf next-next-hop-address { | | leaf next-next-hop-address { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Next Next hop address"; | | "Next Next hop address"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-S2L-OUTPUT-RW-BAG { | | grouping MPLS-TE-S2L-OUTPUT-RW-BAG { |
| description | | description |
| "S2L output rewrite"; | | "S2L output rewrite"; |
| container subfamily { | | container subfamily { |
| description | | description |
| "Subfamily identifiers"; | | "Subfamily identifiers"; |
| uses TE-S2L-OUTPUT-RW-FEC-SUBFAMILY-BAG; | | uses TE-S2L-OUTPUT-RW-FEC-SUBFAMILY-BAG; |
| } | | } |
| container successful-rewrite { | | container successful-rewrite { |
| description | | description |
| "Successful rewrite details"; | | "Successful rewrite details"; |
| uses TE-S2L-OUTPUT-RW-FIELDS-BAG; | | uses TE-S2L-OUTPUT-RW-FIELDS-BAG; |
| } | | } |
| container failed-rewrite { | | container failed-rewrite { |
| description | | description |
| "Failed rewrite details"; | | "Failed rewrite details"; |
| uses TE-S2L-OUTPUT-RW-FIELDS-BAG; | | uses TE-S2L-OUTPUT-RW-FIELDS-BAG; |
| } | | } |
| container pending-rewrite { | | container pending-rewrite { |
| description | | description |
| "Pending rewrite details"; | | "Pending rewrite details"; |
| uses TE-S2L-OUTPUT-RW-FIELDS-BAG; | | uses TE-S2L-OUTPUT-RW-FIELDS-BAG; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-S2L-FORWARDING-BAG { | | grouping MPLS-TE-S2L-FORWARDING-BAG { |
| description | | description |
| "Output label forwarding details for S2Ls"; | | "Output label forwarding details for S2Ls"; |
| container s2l-output-rewrite { | | container s2l-output-rewrite { |
| description | | description |
| "Output rewrite shared between S2Ls"; | | "Output rewrite shared between S2Ls"; |
| uses MPLS-TE-S2L-OUTPUT-RW-BAG; | | uses MPLS-TE-S2L-OUTPUT-RW-BAG; |
| } | | } |
| leaf original-input-interface { | | leaf original-input-interface { |
| type string; | | type string; |
| description | | description |
| "Input interface of the S2Ls"; | | "Input interface of the S2Ls"; |
| } | | } |
| leaf output-interface-name { | | leaf output-interface-name { |
| type string; | | type string; |
| description | | description |
| "The output interface of the S2Ls"; | | "The output interface of the S2Ls"; |
| } | | } |
| leaf backup-tunnel-name { | | leaf backup-tunnel-name { |
| type string; | | type string; |
| description | | description |
| "Backup tunnel name"; | | "Backup tunnel name"; |
| } | | } |
| leaf is-segment-routing { | | leaf is-segment-routing { |
| type boolean; | | type boolean; |
| description | | description |
| "TRUE if the s2l path is Segment-Routing"; | | "TRUE if the s2l path is Segment-Routing"; |
| } | | } |
| list s2l { | | list s2l { |
| description | | description |
| "Unique identifiers for the S2L sharing the | | "Unique identifiers for the S2L sharing the |
| rewrite"; | | rewrite"; |
| uses MPLS-TE-S2L-FORWARDING-S2L-ID-BAG; | | uses MPLS-TE-S2L-FORWARDING-S2L-ID-BAG; |
| } | | } |
| list s2lsr-path { | | list s2lsr-path { |
| description | | description |
| "Segment-Routing Paths"; | | "Segment-Routing Paths"; |
| uses MPLS-TE-SR-S2L-PATH-BAG; | | uses MPLS-TE-SR-S2L-PATH-BAG; |
| } | | } |
| } | | } |
| | | |
| grouping TE-S2L-TUN-RW-FIELDS-P2MP-BAG { | | grouping TE-S2L-TUN-RW-FIELDS-P2MP-BAG { |
| description | | description |
| "LMRIB Tunnel rewrite fields"; | | "LMRIB Tunnel rewrite fields"; |
| leaf local-label { | | leaf local-label { |
| type uint32; | | type uint32; |
| description | | description |
| "Local Label"; | | "Local Label"; |
| } | | } |
| } | | } |
| | | |
| grouping TE-S2L-OUTPUT-RW-OUTPUT-INFO-BAG { | | grouping TE-S2L-OUTPUT-RW-OUTPUT-INFO-BAG { |
| description | | description |
| "Output rewrite tunnel information"; | | "Output rewrite tunnel information"; |
| leaf physica-interface-name { | | leaf physica-interface-name { |
| type xr:Interface-name; | | type xr:Interface-name; |
| description | | description |
| "Physical interface associated with the entry"; | | "Physical interface associated with the entry"; |
| } | | } |
| leaf tunnel-interface-name { | | leaf tunnel-interface-name { |
| type xr:Interface-name; | | type xr:Interface-name; |
| description | | description |
| "Interface handle of the associated tunnel"; | | "Interface handle of the associated tunnel"; |
| } | | } |
| leaf parent-interface-name { | | leaf parent-interface-name { |
| type xr:Interface-name; | | type xr:Interface-name; |
| description | | description |
| "Interface name of the parent intf"; | | "Interface name of the parent intf"; |
| } | | } |
| leaf next-hop-address { | | leaf next-hop-address { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Next hop address associated with the entry"; | | "Next hop address associated with the entry"; |
| } | | } |
| leaf out-label { | | leaf out-label { |
| type uint32; | | type uint32; |
| description | | description |
| "Output label associated with the entry"; | | "Output label associated with the entry"; |
| } | | } |
| list sr-label-stack { | | list sr-label-stack { |
| description | | description |
| "Segment-Routing labels stack"; | | "Segment-Routing labels stack"; |
| leaf entry { | | leaf entry { |
| type uint32; | | type uint32; |
| description | | description |
| "Segment-Routing labels stack"; | | "Segment-Routing labels stack"; |
| } | | } |
| } | | } |
| } | | } |
| | | |
| grouping TE-S2L-TUN-RW-FIELDS-P2P-BAG { | | grouping TE-S2L-TUN-RW-FIELDS-P2P-BAG { |
| description | | description |
| "LSD Tunnel rewrite fields"; | | "LSD Tunnel rewrite fields"; |
| container primary-s2l { | | container primary-s2l { |
| description | | description |
| "Properties of the primary S2L of tunnel rewrite"; | | "Properties of the primary S2L of tunnel rewrite"; |
| uses TE-S2L-OUTPUT-RW-OUTPUT-INFO-BAG; | | uses TE-S2L-OUTPUT-RW-OUTPUT-INFO-BAG; |
| } | | } |
| container backup-tunnel-rewrite { | | container backup-tunnel-rewrite { |
| description | | description |
| "Properties of the S2L's backup for tunnel | | "Properties of the S2L's backup for tunnel |
| rewrite"; | | rewrite"; |
| uses TE-S2L-OUTPUT-RW-OUTPUT-INFO-BAG; | | uses TE-S2L-OUTPUT-RW-OUTPUT-INFO-BAG; |
| } | | } |
| leaf local-label { | | leaf local-label { |
| type uint32; | | type uint32; |
| description | | description |
| "Local label of the tunnel rewrite"; | | "Local label of the tunnel rewrite"; |
| } | | } |
| leaf tunnel-id { | | leaf tunnel-id { |
| type uint16; | | type uint16; |
| description | | description |
| "Tunnel ID for this rewrite data"; | | "Tunnel ID for this rewrite data"; |
| } | | } |
| leaf source-pe { | | leaf source-pe { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "source address of the tunnel"; | | "source address of the tunnel"; |
| } | | } |
| leaf destination-address { | | leaf destination-address { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Destination"; | | "Destination"; |
| } | | } |
| leaf extended-tunnel-id { | | leaf extended-tunnel-id { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Extended Tunnel ID"; | | "Extended Tunnel ID"; |
| } | | } |
| leaf backup-active { | | leaf backup-active { |
| type boolean; | | type boolean; |
| description | | description |
| "FRR is active on the backup tunnel"; | | "FRR is active on the backup tunnel"; |
| } | | } |
| leaf original-input-interface { | | leaf original-input-interface { |
| type string; | | type string; |
| description | | description |
| "Input interface of the S2Ls"; | | "Input interface of the S2Ls"; |
| } | | } |
| leaf previous-hop-address { | | leaf previous-hop-address { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Previous hop"; | | "Previous hop"; |
| } | | } |
| leaf output-interface-name { | | leaf output-interface-name { |
| type string; | | type string; |
| description | | description |
| "The output interface of the S2Ls"; | | "The output interface of the S2Ls"; |
| } | | } |
| leaf backup-tunnel-name { | | leaf backup-tunnel-name { |
| type string; | | type string; |
| description | | description |
| "Backup tunnel name"; | | "Backup tunnel name"; |
| } | | } |
| } | | } |
| | | |
| grouping TE-S2L-TUN-RW-FIELD-CTYPE-BAG { | | grouping TE-S2L-TUN-RW-FIELD-CTYPE-BAG { |
| description | | description |
| "C-type-specific LSP FEC data"; | | "C-type-specific LSP FEC data"; |
| container p2p-tunnel-rewrite { | | container p2p-tunnel-rewrite { |
| when "../fec-ctype = 'mpls-lib-c-type-ipv4-p2p-tunnel'" { | | when "../fec-ctype = 'mpls-lib-c-type-ipv4-p2p-tunnel'" { |
| description | | description |
| "../FEC_CType = 'MPLS_LIB_CTYPE_IPV4_P2P_TUNNEL'"; | | "../FEC_CType = 'MPLS_LIB_CTYPE_IPV4_P2P_TUNNEL'"; |
| } | | } |
| description | | description |
| "Tunnel rewrite data specific to P2P"; | | "Tunnel rewrite data specific to P2P"; |
| uses TE-S2L-TUN-RW-FIELDS-P2P-BAG; | | uses TE-S2L-TUN-RW-FIELDS-P2P-BAG; |
| } | | } |
| container p2mp-tunnel-rewrite { | | container p2mp-tunnel-rewrite { |
| when "../fec-ctype = 'mpls-lib-c-type-ipv4-p2mp-tunnel'" { | | when "../fec-ctype = 'mpls-lib-c-type-ipv4-p2mp-tunnel'" { |
| description | | description |
| "../FEC_CType = | | "../FEC_CType = |
| 'MPLS_LIB_CTYPE_IPV4_P2MP_TUNNEL'"; | | 'MPLS_LIB_CTYPE_IPV4_P2MP_TUNNEL'"; |
| } | | } |
| description | | description |
| "Tunnel rewrite data specific to P2MP"; | | "Tunnel rewrite data specific to P2MP"; |
| uses TE-S2L-TUN-RW-FIELDS-P2MP-BAG; | | uses TE-S2L-TUN-RW-FIELDS-P2MP-BAG; |
| } | | } |
| leaf fec-ctype { | | leaf fec-ctype { |
| type Mpls-lib-c; | | type Mpls-lib-c; |
| description | | description |
| "FEC CType"; | | "FEC CType"; |
| } | | } |
| } | | } |
| | | |
| grouping TE-S2L-TUN-RW-FIELDS-BAG { | | grouping TE-S2L-TUN-RW-FIELDS-BAG { |
| description | | description |
| "LMRIB S2L Tunnel rewrite fields"; | | "LMRIB S2L Tunnel rewrite fields"; |
| container tunnel-rewrite { | | container tunnel-rewrite { |
| description | | description |
| "Union of p2p and p2mp tun rewrite data"; | | "Union of p2p and p2mp tun rewrite data"; |
| uses TE-S2L-TUN-RW-FIELD-CTYPE-BAG; | | uses TE-S2L-TUN-RW-FIELD-CTYPE-BAG; |
| } | | } |
| leaf timestamp { | | leaf timestamp { |
| type uint32; | | type uint32; |
| description | | description |
| "Time stamp of the entry"; | | "Time stamp of the entry"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-S2L-TUN-RW-BAG { | | grouping MPLS-TE-S2L-TUN-RW-BAG { |
| description | | description |
| "LMRIB S2L Tunnel rewrite"; | | "LMRIB S2L Tunnel rewrite"; |
| container successful-rewrite { | | container successful-rewrite { |
| description | | description |
| "Successful rewrite details"; | | "Successful rewrite details"; |
| uses TE-S2L-TUN-RW-FIELDS-BAG; | | uses TE-S2L-TUN-RW-FIELDS-BAG; |
| } | | } |
| container failed-rewrite { | | container failed-rewrite { |
| description | | description |
| "Failed rewrite details"; | | "Failed rewrite details"; |
| uses TE-S2L-TUN-RW-FIELDS-BAG; | | uses TE-S2L-TUN-RW-FIELDS-BAG; |
| } | | } |
| container pending-rewrite { | | container pending-rewrite { |
| description | | description |
| "Pending rewrite details"; | | "Pending rewrite details"; |
| uses TE-S2L-TUN-RW-FIELDS-BAG; | | uses TE-S2L-TUN-RW-FIELDS-BAG; |
| } | | } |
| leaf tunnel-interface { | | leaf tunnel-interface { |
| type string; | | type string; |
| description | | description |
| "Tunnel interface name"; | | "Tunnel interface name"; |
| } | | } |
| leaf tunnel-signal-name { | | leaf tunnel-signal-name { |
| type string; | | type string; |
| description | | description |
| "Tunnel signaled-name"; | | "Tunnel signaled-name"; |
| } | | } |
| leaf is-segment-routing { | | leaf is-segment-routing { |
| type boolean; | | type boolean; |
| description | | description |
| "TRUE if the s2l path is Segment-Routing"; | | "TRUE if the s2l path is Segment-Routing"; |
| } | | } |
| } | | } |
| | | |
| grouping TE-PP-SW-LOG-BAG { | | grouping TE-PP-SW-LOG-BAG { |
| description | | description |
| "The full log of the path protection switchover | | "The full log of the path protection switchover |
| events"; | | events"; |
| leaf path-protection-switchovers { | | leaf path-protection-switchovers { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of path protection switchover | | "Total number of path protection switchover |
| events. This could be more than the entries in | | events. This could be more than the entries in |
| the array"; | | the array"; |
| } | | } |
| leaf maximum-switchover-millisec { | | leaf maximum-switchover-millisec { |
| type uint32; | | type uint32; |
| units "millisecond"; | | units "millisecond"; |
| description | | description |
| "The maximum delay for a switchover in | | "The maximum delay for a switchover in |
| milliseconds"; | | milliseconds"; |
| } | | } |
| leaf average-switchover-millisec { | | leaf average-switchover-millisec { |
| type uint32; | | type uint32; |
| units "millisecond"; | | units "millisecond"; |
| description | | description |
| "The average delay for a switchover in | | "The average delay for a switchover in |
| milliseconds"; | | milliseconds"; |
| } | | } |
| list path-protection-switchover-entry { | | list path-protection-switchover-entry { |
| description | | description |
| "The array of path protection switchover entries"; | | "The array of path protection switchover entries"; |
| uses TE-PP-SW-LOG-ENTRY-BAG; | | uses TE-PP-SW-LOG-ENTRY-BAG; |
| } | | } |
| } | | } |
| | | |
| grouping TUNNEL-MAX-INFO { | | grouping TUNNEL-MAX-INFO { |
| description | | description |
| "Tunnel maximum information bag"; | | "Tunnel maximum information bag"; |
| leaf current-maximum-tunnels { | | leaf current-maximum-tunnels { |
| type uint32; | | type uint32; |
| description | | description |
| "Current Maximum Tunnels"; | | "Current Maximum Tunnels"; |
| } | | } |
| leaf current-maximum-destinations { | | leaf current-maximum-destinations { |
| type uint32; | | type uint32; |
| description | | description |
| "Current Maximum Destinations"; | | "Current Maximum Destinations"; |
| } | | } |
| leaf current-maximum-p2mp-tunnels { | | leaf current-maximum-p2mp-tunnels { |
| type uint32; | | type uint32; |
| description | | description |
| "Current Maximum P2MP Tunnel Count"; | | "Current Maximum P2MP Tunnel Count"; |
| } | | } |
| leaf current-maximum-p2mp-destnation-per-tunnel { | | leaf current-maximum-p2mp-destnation-per-tunnel { |
| type uint32; | | type uint32; |
| description | | description |
| "Current Maximum P2MP Destinations Per Tunnel | | "Current Maximum P2MP Destinations Per Tunnel |
| Count"; | | Count"; |
| } | | } |
| leaf absolute-maximum { | | leaf absolute-maximum { |
| type uint32; | | type uint32; |
| description | | description |
| "Absolute Maximum"; | | "Absolute Maximum"; |
| } | | } |
| leaf current-maximum-autobackups { | | leaf current-maximum-autobackups { |
| type uint32; | | type uint32; |
| description | | description |
| "Current Maximum Autotunnel Backups Allowed"; | | "Current Maximum Autotunnel Backups Allowed"; |
| } | | } |
| leaf current-maximum-auto-mesh { | | leaf current-maximum-auto-mesh { |
| type uint32; | | type uint32; |
| description | | description |
| "Current Maximum Autotunnel Mesh Allowed"; | | "Current Maximum Autotunnel Mesh Allowed"; |
| } | | } |
| leaf current-tunnel-count { | | leaf current-tunnel-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Current tunnel count"; | | "Current tunnel count"; |
| } | | } |
| leaf current-destination-count { | | leaf current-destination-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Current Destination Count"; | | "Current Destination Count"; |
| } | | } |
| leaf current-p2mp-tunnel-count { | | leaf current-p2mp-tunnel-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Current P2MP tunnel count"; | | "Current P2MP tunnel count"; |
| } | | } |
| leaf current-p2mp-destnation-per-tunnel-count { | | leaf current-p2mp-destnation-per-tunnel-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Current P2MP Destination per tunnel count"; | | "Current P2MP Destination per tunnel count"; |
| } | | } |
| leaf is-autobackup-range-configured { | | leaf is-autobackup-range-configured { |
| type boolean; | | type boolean; |
| description | | description |
| "TRUE if the autobackup range is configured"; | | "TRUE if the autobackup range is configured"; |
| } | | } |
| leaf current-autobackups { | | leaf current-autobackups { |
| type uint32; | | type uint32; |
| description | | description |
| "Current Autotunnel Backup count"; | | "Current Autotunnel Backup count"; |
| } | | } |
| leaf is-auto-mesh-range-configured { | | leaf is-auto-mesh-range-configured { |
| type boolean; | | type boolean; |
| description | | description |
| "TRUE if the automesh range is configured"; | | "TRUE if the automesh range is configured"; |
| } | | } |
| leaf current-auto-mesh { | | leaf current-auto-mesh { |
| type uint32; | | type uint32; |
| description | | description |
| "Current Autotunnel Mesh count"; | | "Current Autotunnel Mesh count"; |
| } | | } |
| leaf current-maximum-gmpls-unitunnels { | | leaf current-maximum-gmpls-unitunnels { |
| type uint32; | | type uint32; |
| description | | description |
| "Current Maximum GMPLS-UNI Tunnel Count"; | | "Current Maximum GMPLS-UNI Tunnel Count"; |
| } | | } |
| leaf current-gmpls-uni { | | leaf current-gmpls-uni { |
| type uint32; | | type uint32; |
| description | | description |
| "Current GMPLS-UNI tunnel count"; | | "Current GMPLS-UNI tunnel count"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-S2L-SR-OUTGOING-FWD-INFO { | | grouping MPLS-TE-S2L-SR-OUTGOING-FWD-INFO { |
| description | | description |
| "Segment-routing outgoing fowarding info"; | | "Segment-routing outgoing fowarding info"; |
| leaf lsp-output-interface { | | leaf lsp-output-interface { |
| type string; | | type string; |
| description | | description |
| "Output interface of LSP"; | | "Output interface of LSP"; |
| } | | } |
| leaf lsp-output-label { | | leaf lsp-output-label { |
| type uint32; | | type uint32; |
| description | | description |
| "Output label of the LSP"; | | "Output label of the LSP"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-PATH-PROTECTION-LSP { | | grouping MPLS-TE-PATH-PROTECTION-LSP { |
| description | | description |
| "MPLS TE Path Protected LSP Information"; | | "MPLS TE Path Protected LSP Information"; |
| leaf lsp-uptime { | | leaf lsp-uptime { |
| type uint32; | | type uint32; |
| description | | description |
| "LSP Uptime"; | | "LSP Uptime"; |
| } | | } |
| leaf path-protection-lsp-id { | | leaf path-protection-lsp-id { |
| type uint32; | | type uint32; |
| description | | description |
| "LSP ID "; | | "LSP ID "; |
| } | | } |
| leaf lsp-local-label { | | leaf lsp-local-label { |
| type uint32; | | type uint32; |
| description | | description |
| "Local label "; | | "Local label "; |
| } | | } |
| leaf lsp-output-interface { | | leaf lsp-output-interface { |
| type string; | | type string; |
| description | | description |
| "Output interface of LSP"; | | "Output interface of LSP"; |
| } | | } |
| leaf lsp-output-label { | | leaf lsp-output-label { |
| type uint32; | | type uint32; |
| description | | description |
| "Output label of the LSP"; | | "Output label of the LSP"; |
| } | | } |
| leaf lsp-state { | | leaf lsp-state { |
| type Mpls-te-tunnel-state; | | type Mpls-te-tunnel-state; |
| description | | description |
| "LSP State"; | | "LSP State"; |
| } | | } |
| list srlsp-outgoing-info { | | list srlsp-outgoing-info { |
| description | | description |
| "Segment-routing iutgoing info of LSP"; | | "Segment-routing iutgoing info of LSP"; |
| uses MPLS-TE-S2L-SR-OUTGOING-FWD-INFO; | | uses MPLS-TE-S2L-SR-OUTGOING-FWD-INFO; |
| } | | } |
| list lsp-hop { | | list lsp-hop { |
| description | | description |
| "Path used by LSP"; | | "Path used by LSP"; |
| uses RSVP-MGMT-ERO-SUBOBJ; | | uses RSVP-MGMT-ERO-SUBOBJ; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-PATH-PROTECTION { | | grouping MPLS-TE-PATH-PROTECTION { |
| description | | description |
| "MPLS TE Path Protected Information"; | | "MPLS TE Path Protected Information"; |
| container path-protection { | | container path-protection { |
| description | | description |
| "Path Protect Info"; | | "Path Protect Info"; |
| uses MPLS-TE-PP-INFO; | | uses MPLS-TE-PP-INFO; |
| } | | } |
| container current-lsp { | | container current-lsp { |
| description | | description |
| " Current LSP info"; | | " Current LSP info"; |
| uses MPLS-TE-PATH-PROTECTION-LSP; | | uses MPLS-TE-PATH-PROTECTION-LSP; |
| } | | } |
| container standby-lsp { | | container standby-lsp { |
| description | | description |
| " Standby LSP info"; | | " Standby LSP info"; |
| uses MPLS-TE-PATH-PROTECTION-LSP; | | uses MPLS-TE-PATH-PROTECTION-LSP; |
| } | | } |
| leaf is-tunnel-up { | | leaf is-tunnel-up { |
| type boolean; | | type boolean; |
| description | | description |
| "Tunnel UP"; | | "Tunnel UP"; |
| } | | } |
| leaf source-address { | | leaf source-address { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Source"; | | "Source"; |
| } | | } |
| leaf destination-address { | | leaf destination-address { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Destination"; | | "Destination"; |
| } | | } |
| leaf extended-tunnel-id { | | leaf extended-tunnel-id { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Extended Tunnel ID"; | | "Extended Tunnel ID"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-AUTOTUN-P2P-INFO { | | grouping MPLS-TE-AUTOTUN-P2P-INFO { |
| description | | description |
| "P2P auto-tunnel summary per client information"; | | "P2P auto-tunnel summary per client information"; |
| leaf auto-p2p-tunnel { | | leaf auto-p2p-tunnel { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of client P2P auto-tunnels"; | | "Total number of client P2P auto-tunnels"; |
| } | | } |
| leaf up-auto-p2p-tunnels { | | leaf up-auto-p2p-tunnels { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of client P2P auto-tunnels that are | | "Total number of client P2P auto-tunnels that are |
| up"; | | up"; |
| } | | } |
| leaf down-auto-p2p-tunnels { | | leaf down-auto-p2p-tunnels { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of client P2P auto-tunnels that are | | "Total number of client P2P auto-tunnels that are |
| down"; | | down"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-AUTOTUN-P2MP-INFO { | | grouping MPLS-TE-AUTOTUN-P2MP-INFO { |
| description | | description |
| "P2MP auto-tunnel summary per client information"; | | "P2MP auto-tunnel summary per client information"; |
| leaf auto-p2mp-tunnel { | | leaf auto-p2mp-tunnel { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of client P2MP auto-tunnels"; | | "Total number of client P2MP auto-tunnels"; |
| } | | } |
| leaf auto-p2mp-destinations { | | leaf auto-p2mp-destinations { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of client P2MP auto-tunnel | | "Total number of client P2MP auto-tunnel |
| destinations"; | | destinations"; |
| } | | } |
| leaf up-auto-p2mp-destinations { | | leaf up-auto-p2mp-destinations { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of client P2MP auto-tunnel | | "Total number of client P2MP auto-tunnel |
| destinations that are up"; | | destinations that are up"; |
| } | | } |
| leaf down-auto-p2mp-destinations { | | leaf down-auto-p2mp-destinations { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of client P2MP auto-tunnel | | "Total number of client P2MP auto-tunnel |
| destinations that are down"; | | destinations that are down"; |
| } | | } |
| leaf up-auto-p2mp-tunnels { | | leaf up-auto-p2mp-tunnels { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of client P2MP auto-tunnels that | | "Total number of client P2MP auto-tunnels that |
| are up"; | | are up"; |
| } | | } |
| leaf down-auto-p2mp-tunnels { | | leaf down-auto-p2mp-tunnels { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of client P2MP auto-tunnels that | | "Total number of client P2MP auto-tunnels that |
| are down"; | | are down"; |
| } | | } |
| leaf frr-auto-p2mp-tunnels { | | leaf frr-auto-p2mp-tunnels { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of client P2MP auto-tunnels that | | "Total number of client P2MP auto-tunnels that |
| are FRR enabled"; | | are FRR enabled"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-AUTOTUN-SVR-INFO { | | grouping MPLS-TE-AUTOTUN-SVR-INFO { |
| description | | description |
| "Auto-tunnel server client summary"; | | "Auto-tunnel server client summary"; |
| container p2mp-info { | | container p2mp-info { |
| description | | description |
| "P2MP info for a client"; | | "P2MP info for a client"; |
| uses MPLS-TE-AUTOTUN-P2MP-INFO; | | uses MPLS-TE-AUTOTUN-P2MP-INFO; |
| } | | } |
| container p2p-info { | | container p2p-info { |
| description | | description |
| "P2P info for a client"; | | "P2P info for a client"; |
| uses MPLS-TE-AUTOTUN-P2P-INFO; | | uses MPLS-TE-AUTOTUN-P2P-INFO; |
| } | | } |
| leaf protocol-type { | | leaf protocol-type { |
| type Te-serv-tun-client; | | type Te-serv-tun-client; |
| description | | description |
| "Client's protocol type"; | | "Client's protocol type"; |
| } | | } |
| leaf client-instance-name { | | leaf client-instance-name { |
| type string; | | type string; |
| description | | description |
| "Client Instance name"; | | "Client Instance name"; |
| } | | } |
| leaf client-id { | | leaf client-id { |
| type uint32; | | type uint32; |
| description | | description |
| "Client ID"; | | "Client ID"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-AUTOTUN-SVR-SUMMARY-INFO { | | grouping MPLS-TE-AUTOTUN-SVR-SUMMARY-INFO { |
| description | | description |
| "Auto-tunnel server summary information"; | | "Auto-tunnel server summary information"; |
| container total-auto-p2mp-tunnels { | | container total-auto-p2mp-tunnels { |
| description | | description |
| "Total number of P2MP auto-tunnels"; | | "Total number of P2MP auto-tunnels"; |
| uses MPLS-TE-AUTOTUN-P2MP-INFO; | | uses MPLS-TE-AUTOTUN-P2MP-INFO; |
| } | | } |
| container total-auto-p2p-tunnels { | | container total-auto-p2p-tunnels { |
| description | | description |
| "Total number of P2P auto-tunnels"; | | "Total number of P2P auto-tunnels"; |
| uses MPLS-TE-AUTOTUN-P2P-INFO; | | uses MPLS-TE-AUTOTUN-P2P-INFO; |
| } | | } |
| list clients-summary { | | list clients-summary { |
| description | | description |
| "List of auto-tunnel server clients"; | | "List of auto-tunnel server clients"; |
| uses MPLS-TE-AUTOTUN-SVR-INFO; | | uses MPLS-TE-AUTOTUN-SVR-INFO; |
| } | | } |
| } | | } |
| | | |
| grouping TE-CONV-TBL-SUMMARY-BAG { | | grouping TE-CONV-TBL-SUMMARY-BAG { |
| description | | description |
| "TE tunnels convergence summary information bag"; | | "TE tunnels convergence summary information bag"; |
| leaf tunnel-frr-active-count { | | leaf tunnel-frr-active-count { |
| type uint32; | | type uint32; |
| description | | description |
| "FRR active Tunnel count"; | | "FRR active Tunnel count"; |
| } | | } |
| leaf tunnel-frr-total-count { | | leaf tunnel-frr-total-count { |
| type uint32; | | type uint32; |
| description | | description |
| "FRR triggered Tunnel count"; | | "FRR triggered Tunnel count"; |
| } | | } |
| leaf tunnel-converged-count { | | leaf tunnel-converged-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Tunnel converged count"; | | "Tunnel converged count"; |
| } | | } |
| leaf tunnel-total-convergence-complete-time { | | leaf tunnel-total-convergence-complete-time { |
| type uint64; | | type uint64; |
| units "nanosecond"; | | units "nanosecond"; |
| description | | description |
| "Tunnel convergence complete timestamp (clocktime | | "Tunnel convergence complete timestamp (clocktime |
| in nsecs)"; | | in nsecs)"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-GMPLS-NNI-SUMMARY-INFO { | | grouping MPLS-TE-GMPLS-NNI-SUMMARY-INFO { |
| description | | description |
| "GMPLS-NNI summary information"; | | "GMPLS-NNI summary information"; |
| leaf heads-up { | | leaf heads-up { |
| type uint32; | | type uint32; |
| description | | description |
| "Tunnel heads in up state"; | | "Tunnel heads in up state"; |
| } | | } |
| leaf heads-down { | | leaf heads-down { |
| type uint32; | | type uint32; |
| description | | description |
| "Tunnel heads in down state"; | | "Tunnel heads in down state"; |
| } | | } |
| leaf mids-up { | | leaf mids-up { |
| type uint32; | | type uint32; |
| description | | description |
| "Tunnel mids in up state"; | | "Tunnel mids in up state"; |
| } | | } |
| leaf mids-down { | | leaf mids-down { |
| type uint32; | | type uint32; |
| description | | description |
| "Tunnel mids in down state"; | | "Tunnel mids in down state"; |
| } | | } |
| leaf tails-up { | | leaf tails-up { |
| type uint32; | | type uint32; |
| description | | description |
| "Tunnel tails in up state"; | | "Tunnel tails in up state"; |
| } | | } |
| leaf tails-down { | | leaf tails-down { |
| type uint32; | | type uint32; |
| description | | description |
| "Tunnel tails in down state"; | | "Tunnel tails in down state"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-GMPLS-UNI-SUMMARY-INFO { | | grouping MPLS-TE-GMPLS-UNI-SUMMARY-INFO { |
| description | | description |
| "GMPLS-UNI summary information"; | | "GMPLS-UNI summary information"; |
| leaf heads-up { | | leaf heads-up { |
| type uint32; | | type uint32; |
| description | | description |
| "Tunnel heads in up state"; | | "Tunnel heads in up state"; |
| } | | } |
| leaf heads-down { | | leaf heads-down { |
| type uint32; | | type uint32; |
| description | | description |
| "Tunnel heads in down state"; | | "Tunnel heads in down state"; |
| } | | } |
| leaf tails-up { | | leaf tails-up { |
| type uint32; | | type uint32; |
| description | | description |
| "Tunnel tails in up state"; | | "Tunnel tails in up state"; |
| } | | } |
| leaf tails-down { | | leaf tails-down { |
| type uint32; | | type uint32; |
| description | | description |
| "Tunnel tails in down state"; | | "Tunnel tails in down state"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-TUNNELS-SUMMARY-INFO-BAG { | | grouping MPLS-TE-TUNNELS-SUMMARY-INFO-BAG { |
| description | | description |
| "MPLS TE Tunnel Summary Information"; | | "MPLS TE Tunnel Summary Information"; |
| container autobackup-summary { | | container autobackup-summary { |
| description | | description |
| "Autobackup summary"; | | "Autobackup summary"; |
| uses MPLS-TE-AUTOTUN-BACKUP-SUMMARY-INFO; | | uses MPLS-TE-AUTOTUN-BACKUP-SUMMARY-INFO; |
| } | | } |
| container auto-mesh-summary { | | container auto-mesh-summary { |
| description | | description |
| "Automesh summary"; | | "Automesh summary"; |
| uses MPLS-TE-AUTOTUN-MESH-SUMMARY-INFO; | | uses MPLS-TE-AUTOTUN-MESH-SUMMARY-INFO; |
| } | | } |
| container auto-mesh-one-hop-summary { | | container auto-mesh-one-hop-summary { |
| description | | description |
| "Automesh Onehop summary"; | | "Automesh Onehop summary"; |
| uses MPLS-TE-AUTOTUN-MESH-ONEHOP-SUMMARY-INFO; | | uses MPLS-TE-AUTOTUN-MESH-ONEHOP-SUMMARY-INFO; |
| } | | } |
| container gmpls-uni-summary { | | container gmpls-uni-summary { |
| description | | description |
| "GMPLS-UNI summary"; | | "GMPLS-UNI summary"; |
| uses MPLS-TE-GMPLS-UNI-SUMMARY-INFO; | | uses MPLS-TE-GMPLS-UNI-SUMMARY-INFO; |
| } | | } |
| container gmpls-nni-summary { | | container gmpls-nni-summary { |
| description | | description |
| "GMPLS-NNI summary"; | | "GMPLS-NNI summary"; |
| uses MPLS-TE-GMPLS-NNI-SUMMARY-INFO; | | uses MPLS-TE-GMPLS-NNI-SUMMARY-INFO; |
| } | | } |
| container current-tunnel-convergence-summary { | | container current-tunnel-convergence-summary { |
| description | | description |
| "Current Tunnel convergemce summary information"; | | "Current Tunnel convergemce summary information"; |
| uses TE-CONV-TBL-SUMMARY-BAG; | | uses TE-CONV-TBL-SUMMARY-BAG; |
| } | | } |
| container last-tunnel-convergence-summary { | | container last-tunnel-convergence-summary { |
| description | | description |
| "Last Tunnel convergemce summary information"; | | "Last Tunnel convergemce summary information"; |
| uses TE-CONV-TBL-SUMMARY-BAG; | | uses TE-CONV-TBL-SUMMARY-BAG; |
| } | | } |
| container auto-tun-server-summary { | | container auto-tun-server-summary { |
| description | | description |
| "Auto-tunnel server tunnel summary"; | | "Auto-tunnel server tunnel summary"; |
| uses MPLS-TE-AUTOTUN-SVR-SUMMARY-INFO; | | uses MPLS-TE-AUTOTUN-SVR-SUMMARY-INFO; |
| } | | } |
| leaf pcalc-tie-breaker-type { | | leaf pcalc-tie-breaker-type { |
| type Te-path-selection-tiebreaker; | | type Te-path-selection-tiebreaker; |
| description | | description |
| "PCALC tiebreaker type"; | | "PCALC tiebreaker type"; |
| } | | } |
| leaf pcalc-tiebreaker { | | leaf pcalc-tiebreaker { |
| type uint32; | | type uint32; |
| description | | description |
| "Deprecated - replaced by PCALCTiebreakerType"; | | "Deprecated - replaced by PCALCTiebreakerType"; |
| } | | } |
| leaf tiebreaker-qualifier { | | leaf tiebreaker-qualifier { |
| type Mpls-te-metric-qualifier; | | type Mpls-te-metric-qualifier; |
| description | | description |
| "Describes how the path selection tiebreaker was | | "Describes how the path selection tiebreaker was |
| specified:default, or globally set"; | | specified:default, or globally set"; |
| } | | } |
| leaf te-process-status { | | leaf te-process-status { |
| type Mpls-te-tunnels-process-status; | | type Mpls-te-tunnels-process-status; |
| description | | description |
| "Status of te_control"; | | "Status of te_control"; |
| } | | } |
| leaf is-rsvp-process-enabled { | | leaf is-rsvp-process-enabled { |
| type boolean; | | type boolean; |
| description | | description |
| "Status of rsvp"; | | "Status of rsvp"; |
| } | | } |
| leaf is-forwarding-enabled { | | leaf is-forwarding-enabled { |
| type boolean; | | type boolean; |
| description | | description |
| "TRUE if forwarding is enabled"; | | "TRUE if forwarding is enabled"; |
| } | | } |
| leaf activated-heads { | | leaf activated-heads { |
| type uint32; | | type uint32; |
| description | | description |
| "Total tunnel heads activated"; | | "Total tunnel heads activated"; |
| } | | } |
| leaf deactivated-heads { | | leaf deactivated-heads { |
| type uint32; | | type uint32; |
| description | | description |
| "Total tunnel heads deactivated"; | | "Total tunnel heads deactivated"; |
| } | | } |
| leaf recovered-heads { | | leaf recovered-heads { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of heads recovered"; | | "Number of heads recovered"; |
| } | | } |
| leaf is-periodic-reoptimization-on { | | leaf is-periodic-reoptimization-on { |
| type boolean; | | type boolean; |
| description | | description |
| "TRUE if periodic reoptimization is on"; | | "TRUE if periodic reoptimization is on"; |
| } | | } |
| leaf reoptimization-period { | | leaf reoptimization-period { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Reoptimization period in seconds"; | | "Reoptimization period in seconds"; |
| } | | } |
| leaf next-reoptimization-timer { | | leaf next-reoptimization-timer { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Time left till next reoptimization (seconds)"; | | "Time left till next reoptimization (seconds)"; |
| } | | } |
| leaf auto-bandwidth-tunnels { | | leaf auto-bandwidth-tunnels { |
| type uint32; | | type uint32; |
| description | | description |
| "Counter with number of auto-bw enabled tunnels"; | | "Counter with number of auto-bw enabled tunnels"; |
| } | | } |
| leaf auto-bandwidth-collection-period { | | leaf auto-bandwidth-collection-period { |
| type uint32; | | type uint32; |
| units "minute"; | | units "minute"; |
| description | | description |
| "Collection period in minutes"; | | "Collection period in minutes"; |
| } | | } |
| leaf is-promotion-on { | | leaf is-promotion-on { |
| type boolean; | | type boolean; |
| description | | description |
| "TRUE if periodic frr promotion is on"; | | "TRUE if periodic frr promotion is on"; |
| } | | } |
| leaf promotion-period { | | leaf promotion-period { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "FRR promotion period in seconds"; | | "FRR promotion period in seconds"; |
| } | | } |
| leaf next-promotion-timer { | | leaf next-promotion-timer { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Time left till next FRR promotion (seconds)"; | | "Time left till next FRR promotion (seconds)"; |
| } | | } |
| leaf tunnel-check-period { | | leaf tunnel-check-period { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Tunnel head check period (seconds)"; | | "Tunnel head check period (seconds)"; |
| } | | } |
| leaf next-check-time { | | leaf next-check-time { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Time left till next FRR promotion (seconds)"; | | "Time left till next FRR promotion (seconds)"; |
| } | | } |
| leaf tunnel-verify-period { | | leaf tunnel-verify-period { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Tunnel head verify period (seconds)"; | | "Tunnel head verify period (seconds)"; |
| } | | } |
| leaf next-verify-timer { | | leaf next-verify-timer { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Time left till next FRR promotion (seconds)"; | | "Time left till next FRR promotion (seconds)"; |
| } | | } |
| leaf frr-head-tunnels { | | leaf frr-head-tunnels { |
| type uint32; | | type uint32; |
| description | | description |
| "FRR tunnels in Up state at head end"; | | "FRR tunnels in Up state at head end"; |
| } | | } |
| leaf protected-head-tunnels { | | leaf protected-head-tunnels { |
| type uint32; | | type uint32; |
| description | | description |
| "FRR protected tunnels in Up state at head end"; | | "FRR protected tunnels in Up state at head end"; |
| } | | } |
| leaf rerouted-head-tunnels { | | leaf rerouted-head-tunnels { |
| type uint32; | | type uint32; |
| description | | description |
| "FRR rerouted tunnels in Up state at head end"; | | "FRR rerouted tunnels in Up state at head end"; |
| } | | } |
| leaf frr-mid-point-tunnels { | | leaf frr-mid-point-tunnels { |
| type uint32; | | type uint32; |
| description | | description |
| "FRR tunnels at mid point"; | | "FRR tunnels at mid point"; |
| } | | } |
| leaf protected-mid-point-tunnels { | | leaf protected-mid-point-tunnels { |
| type uint32; | | type uint32; |
| description | | description |
| "FRR protected tunnels at mid point"; | | "FRR protected tunnels at mid point"; |
| } | | } |
| leaf rerouted-mid-point-tunnels { | | leaf rerouted-mid-point-tunnels { |
| type uint32; | | type uint32; |
| description | | description |
| "FRR rerouted tunnels at mid point"; | | "FRR rerouted tunnels at mid point"; |
| } | | } |
| leaf link-protected-tunnels { | | leaf link-protected-tunnels { |
| type uint32; | | type uint32; |
| description | | description |
| "FRR link protected tunnels"; | | "FRR link protected tunnels"; |
| } | | } |
| leaf node-protected-tunnels { | | leaf node-protected-tunnels { |
| type uint32; | | type uint32; |
| description | | description |
| "FRR node protected tunnels"; | | "FRR node protected tunnels"; |
| } | | } |
| leaf bw-protected-tunnels { | | leaf bw-protected-tunnels { |
| type uint32; | | type uint32; |
| description | | description |
| "FRR BW protected tunnels"; | | "FRR BW protected tunnels"; |
| } | | } |
| leaf frr-p2p-head-tunnels { | | leaf frr-p2p-head-tunnels { |
| type uint32; | | type uint32; |
| description | | description |
| "P2P FRR tunnels in Up state at head end"; | | "P2P FRR tunnels in Up state at head end"; |
| } | | } |
| leaf protected-p2p-head-tunnels { | | leaf protected-p2p-head-tunnels { |
| type uint32; | | type uint32; |
| description | | description |
| "P2P FRR protected tunnels in Up state at head | | "P2P FRR protected tunnels in Up state at head |
| end"; | | end"; |
| } | | } |
| leaf rerouted-p2p-head-tunnels { | | leaf rerouted-p2p-head-tunnels { |
| type uint32; | | type uint32; |
| description | | description |
| "P2P FRR rerouted tunnels in Up state at head end"; | | "P2P FRR rerouted tunnels in Up state at head end"; |
| } | | } |
| leaf frr-p2p-mid-point-tunnels { | | leaf frr-p2p-mid-point-tunnels { |
| type uint32; | | type uint32; |
| description | | description |
| "P2P FRR tunnels at mid point"; | | "P2P FRR tunnels at mid point"; |
| } | | } |
| leaf protected-p2p-mid-point-tunnels { | | leaf protected-p2p-mid-point-tunnels { |
| type uint32; | | type uint32; |
| description | | description |
| "P2P FRR protected tunnels at mid point"; | | "P2P FRR protected tunnels at mid point"; |
| } | | } |
| leaf rerouted-p2p-mid-point-tunnels { | | leaf rerouted-p2p-mid-point-tunnels { |
| type uint32; | | type uint32; |
| description | | description |
| "P2P FRR rerouted tunnels at mid point"; | | "P2P FRR rerouted tunnels at mid point"; |
| } | | } |
| leaf link-protected-p2p-tunnels { | | leaf link-protected-p2p-tunnels { |
| type uint32; | | type uint32; |
| description | | description |
| "P2P FRR link protected tunnels"; | | "P2P FRR link protected tunnels"; |
| } | | } |
| leaf node-protected-p2p-tunnels { | | leaf node-protected-p2p-tunnels { |
| type uint32; | | type uint32; |
| description | | description |
| "P2P FRR node protected tunnels"; | | "P2P FRR node protected tunnels"; |
| } | | } |
| leaf bw-protected-p2p-tunnels { | | leaf bw-protected-p2p-tunnels { |
| type uint32; | | type uint32; |
| description | | description |
| "P2P FRR BW protected tunnels"; | | "P2P FRR BW protected tunnels"; |
| } | | } |
| leaf backup-tunnels { | | leaf backup-tunnels { |
| type uint32; | | type uint32; |
| description | | description |
| "FRR backup tunnels in Up state"; | | "FRR backup tunnels in Up state"; |
| } | | } |
| leaf backups-assigned { | | leaf backups-assigned { |
| type uint32; | | type uint32; |
| description | | description |
| "FRR backup tunnels assigned"; | | "FRR backup tunnels assigned"; |
| } | | } |
| leaf frr-protected-interfaces { | | leaf frr-protected-interfaces { |
| type uint32; | | type uint32; |
| description | | description |
| "FRR Protected Interfaces"; | | "FRR Protected Interfaces"; |
| } | | } |
| leaf rerouted-interfaces { | | leaf rerouted-interfaces { |
| type uint32; | | type uint32; |
| description | | description |
| "FRR Rerouted Interfaces"; | | "FRR Rerouted Interfaces"; |
| } | | } |
| leaf p2p-head-tunnels { | | leaf p2p-head-tunnels { |
| type uint32; | | type uint32; |
| description | | description |
| "p2p Tunnel interfaces"; | | "p2p Tunnel interfaces"; |
| } | | } |
| leaf up-p2p-head-tunnels { | | leaf up-p2p-head-tunnels { |
| type uint32; | | type uint32; |
| description | | description |
| "p2p Tunnel interfaces in Up state"; | | "p2p Tunnel interfaces in Up state"; |
| } | | } |
| leaf dynamic-up-p2p-head-tunnels { | | leaf dynamic-up-p2p-head-tunnels { |
| type uint32; | | type uint32; |
| description | | description |
| "p2p Tunnel up via a dynamic path"; | | "p2p Tunnel up via a dynamic path"; |
| } | | } |
| leaf frr-config-p2p-head-tunnels { | | leaf frr-config-p2p-head-tunnels { |
| type uint32; | | type uint32; |
| description | | description |
| "p2p Tunnel interfaces with FRR configuration"; | | "p2p Tunnel interfaces with FRR configuration"; |
| } | | } |
| leaf p2p-head-destinations { | | leaf p2p-head-destinations { |
| type uint32; | | type uint32; |
| description | | description |
| "p2p Destinations at Head"; | | "p2p Destinations at Head"; |
| } | | } |
| leaf p2p-head-destinations-up { | | leaf p2p-head-destinations-up { |
| type uint32; | | type uint32; |
| description | | description |
| "p2p Destinations in Up state at Head"; | | "p2p Destinations in Up state at Head"; |
| } | | } |
| leaf bw-protected-p2p-s2-ls { | | leaf bw-protected-p2p-s2-ls { |
| type uint32; | | type uint32; |
| description | | description |
| "p2p S2Ls BW Protected"; | | "p2p S2Ls BW Protected"; |
| } | | } |
| leaf link-protected-p2p-s2-ls { | | leaf link-protected-p2p-s2-ls { |
| type uint32; | | type uint32; |
| description | | description |
| "p2p S2Ls Link Protected"; | | "p2p S2Ls Link Protected"; |
| } | | } |
| leaf up-p2p-head-s2-ls { | | leaf up-p2p-head-s2-ls { |
| type uint32; | | type uint32; |
| description | | description |
| "p2p S2Ls in Up state at Head"; | | "p2p S2Ls in Up state at Head"; |
| } | | } |
| leaf proceeding-p2p-head-s2-ls { | | leaf proceeding-p2p-head-s2-ls { |
| type uint32; | | type uint32; |
| description | | description |
| "p2p S2Ls in signalling-proceeding state at Head"; | | "p2p S2Ls in signalling-proceeding state at Head"; |
| } | | } |
| leaf recovering-p2p-head-s2-ls { | | leaf recovering-p2p-head-s2-ls { |
| type uint32; | | type uint32; |
| description | | description |
| "p2p S2Ls recovering at Head"; | | "p2p S2Ls recovering at Head"; |
| } | | } |
| leaf frr-p2p-head-s2-ls { | | leaf frr-p2p-head-s2-ls { |
| type uint32; | | type uint32; |
| description | | description |
| "p2p S2Ls with FRR requested at Head"; | | "p2p S2Ls with FRR requested at Head"; |
| } | | } |
| leaf protected-p2p-head-s2-ls { | | leaf protected-p2p-head-s2-ls { |
| type uint32; | | type uint32; |
| description | | description |
| "p2p S2Ls FRR Protected at Head"; | | "p2p S2Ls FRR Protected at Head"; |
| } | | } |
| leaf rerouted-p2p-head-s2-ls { | | leaf rerouted-p2p-head-s2-ls { |
| type uint32; | | type uint32; |
| description | | description |
| "p2p S2Ls FRR Rerouted at Head"; | | "p2p S2Ls FRR Rerouted at Head"; |
| } | | } |
| leaf p2p-mid-point-s2-ls { | | leaf p2p-mid-point-s2-ls { |
| type uint32; | | type uint32; |
| description | | description |
| "p2p S2Ls at Mid"; | | "p2p S2Ls at Mid"; |
| } | | } |
| leaf up-p2p-mid-point-s2-ls { | | leaf up-p2p-mid-point-s2-ls { |
| type uint32; | | type uint32; |
| description | | description |
| "p2p S2Ls in Up state at Mid"; | | "p2p S2Ls in Up state at Mid"; |
| } | | } |
| leaf proceeding-p2p-mid-point-s2-ls { | | leaf proceeding-p2p-mid-point-s2-ls { |
| type uint32; | | type uint32; |
| description | | description |
| "p2p S2Ls in signalling=proceeding state at Mid"; | | "p2p S2Ls in signalling=proceeding state at Mid"; |
| } | | } |
| leaf frr-p2p-mid-point-s2-ls { | | leaf frr-p2p-mid-point-s2-ls { |
| type uint32; | | type uint32; |
| description | | description |
| "p2p S2Ls with FRR requested at Mid"; | | "p2p S2Ls with FRR requested at Mid"; |
| } | | } |
| leaf protected-p2p-mid-point-s2-ls { | | leaf protected-p2p-mid-point-s2-ls { |
| type uint32; | | type uint32; |
| description | | description |
| "p2p S2Ls FRR Protected at Mid"; | | "p2p S2Ls FRR Protected at Mid"; |
| } | | } |
| leaf rerouted-p2p-mid-point-s2-ls { | | leaf rerouted-p2p-mid-point-s2-ls { |
| type uint32; | | type uint32; |
| description | | description |
| "p2p S2Ls FRR Rerouted at Mid"; | | "p2p S2Ls FRR Rerouted at Mid"; |
| } | | } |
| leaf p2p-tail-s2-ls { | | leaf p2p-tail-s2-ls { |
| type uint32; | | type uint32; |
| description | | description |
| "p2p S2Ls at Tail"; | | "p2p S2Ls at Tail"; |
| } | | } |
| leaf up-p2p-tail-s2-ls { | | leaf up-p2p-tail-s2-ls { |
| type uint32; | | type uint32; |
| description | | description |
| "p2p S2Ls in Up state at Tail"; | | "p2p S2Ls in Up state at Tail"; |
| } | | } |
| leaf p2p-tail-tunnels { | | leaf p2p-tail-tunnels { |
| type uint32; | | type uint32; |
| description | | description |
| "p2p Tunnel tail interfaces"; | | "p2p Tunnel tail interfaces"; |
| } | | } |
| leaf path-protect-configured-tunnels { | | leaf path-protect-configured-tunnels { |
| type uint16; | | type uint16; |
| description | | description |
| "Tunnels configured with Path Protect"; | | "Tunnels configured with Path Protect"; |
| } | | } |
| leaf path-protect-configured-tunnels-up { | | leaf path-protect-configured-tunnels-up { |
| type uint16; | | type uint16; |
| description | | description |
| "Path Protect configured tunnels connected/up"; | | "Path Protect configured tunnels connected/up"; |
| } | | } |
| leaf path-protect-configured-tunnels-standby-up { | | leaf path-protect-configured-tunnels-standby-up { |
| type uint16; | | type uint16; |
| description | | description |
| "Tunnels with standby LSP up"; | | "Tunnels with standby LSP up"; |
| } | | } |
| leaf link-diverse-paths { | | leaf link-diverse-paths { |
| type uint16; | | type uint16; |
| description | | description |
| "Link diverse paths"; | | "Link diverse paths"; |
| } | | } |
| leaf node-diverse-paths { | | leaf node-diverse-paths { |
| type uint16; | | type uint16; |
| description | | description |
| "Node diverse paths"; | | "Node diverse paths"; |
| } | | } |
| leaf link-and-node-diverse-paths { | | leaf link-and-node-diverse-paths { |
| type uint16; | | type uint16; |
| description | | description |
| "Link and Node diverse paths"; | | "Link and Node diverse paths"; |
| } | | } |
| leaf user-defined-paths { | | leaf user-defined-paths { |
| type uint16; | | type uint16; |
| description | | description |
| "User defined paths"; | | "User defined paths"; |
| } | | } |
| leaf srlg-diverse-paths { | | leaf srlg-diverse-paths { |
| type uint16; | | type uint16; |
| description | | description |
| "SRLG diverse paths"; | | "SRLG diverse paths"; |
| } | | } |
| leaf srlg-and-node-diverse-paths { | | leaf srlg-and-node-diverse-paths { |
| type uint16; | | type uint16; |
| description | | description |
| "SRLG and Node diverse paths"; | | "SRLG and Node diverse paths"; |
| } | | } |
| leaf srlg-and-node-and-link-diverse-paths { | | leaf srlg-and-node-and-link-diverse-paths { |
| type uint16; | | type uint16; |
| description | | description |
| "SRLG and Node and Link diverse paths"; | | "SRLG and Node and Link diverse paths"; |
| } | | } |
| leaf sticky-paths { | | leaf sticky-paths { |
| type uint16; | | type uint16; |
| description | | description |
| "Sticky paths"; | | "Sticky paths"; |
| } | | } |
| leaf p2mp-head-tunnels { | | leaf p2mp-head-tunnels { |
| type uint32; | | type uint32; |
| description | | description |
| "P2MP Tunnel interfaces"; | | "P2MP Tunnel interfaces"; |
| } | | } |
| leaf up-p2mp-head-tunnels { | | leaf up-p2mp-head-tunnels { |
| type uint32; | | type uint32; |
| description | | description |
| "P2MP Tunnel interfaces in Up state"; | | "P2MP Tunnel interfaces in Up state"; |
| } | | } |
| leaf frr-config-p2mp-head-tunnels { | | leaf frr-config-p2mp-head-tunnels { |
| type uint32; | | type uint32; |
| description | | description |
| "P2MP Tunnel interfaces with FRR configuration"; | | "P2MP Tunnel interfaces with FRR configuration"; |
| } | | } |
| leaf p2mp-head-destinations { | | leaf p2mp-head-destinations { |
| type uint32; | | type uint32; |
| description | | description |
| "P2MP Destinations at Head"; | | "P2MP Destinations at Head"; |
| } | | } |
| leaf up-p2mp-head-destinations { | | leaf up-p2mp-head-destinations { |
| type uint32; | | type uint32; |
| description | | description |
| "P2MP Destinations in Up state at Head"; | | "P2MP Destinations in Up state at Head"; |
| } | | } |
| leaf bw-protected-p2mp-s2-ls { | | leaf bw-protected-p2mp-s2-ls { |
| type uint32; | | type uint32; |
| description | | description |
| "P2MP S2Ls BW Protected"; | | "P2MP S2Ls BW Protected"; |
| } | | } |
| leaf link-protected-p2mp-s2-ls { | | leaf link-protected-p2mp-s2-ls { |
| type uint32; | | type uint32; |
| description | | description |
| "P2MP S2Ls Link Protected"; | | "P2MP S2Ls Link Protected"; |
| } | | } |
| leaf up-p2mp-head-s2-ls { | | leaf up-p2mp-head-s2-ls { |
| type uint32; | | type uint32; |
| description | | description |
| "P2MP S2Ls in Up state at Head"; | | "P2MP S2Ls in Up state at Head"; |
| } | | } |
| leaf proceeding-p2mp-head-s2-ls { | | leaf proceeding-p2mp-head-s2-ls { |
| type uint32; | | type uint32; |
| description | | description |
| "P2MP S2Ls in signalling-proceeding state at Head"; | | "P2MP S2Ls in signalling-proceeding state at Head"; |
| } | | } |
| leaf frr-p2mp-head-s2-ls { | | leaf frr-p2mp-head-s2-ls { |
| type uint32; | | type uint32; |
| description | | description |
| "P2MP S2Ls with FRR requested at Head"; | | "P2MP S2Ls with FRR requested at Head"; |
| } | | } |
| leaf protected-p2mp-head-s2-ls { | | leaf protected-p2mp-head-s2-ls { |
| type uint32; | | type uint32; |
| description | | description |
| "P2MP S2Ls FRR Protected at Head"; | | "P2MP S2Ls FRR Protected at Head"; |
| } | | } |
| leaf rerouted-p2mp-head-s2-ls { | | leaf rerouted-p2mp-head-s2-ls { |
| type uint32; | | type uint32; |
| description | | description |
| "P2MP S2Ls FRR Rerouted at Head"; | | "P2MP S2Ls FRR Rerouted at Head"; |
| } | | } |
| leaf p2mp-mid-point-s2-ls { | | leaf p2mp-mid-point-s2-ls { |
| type uint32; | | type uint32; |
| description | | description |
| "P2MP S2Ls at Mid"; | | "P2MP S2Ls at Mid"; |
| } | | } |
| leaf up-p2mp-mid-point-s2-ls { | | leaf up-p2mp-mid-point-s2-ls { |
| type uint32; | | type uint32; |
| description | | description |
| "P2MP S2Ls in Up state at Mid"; | | "P2MP S2Ls in Up state at Mid"; |
| } | | } |
| leaf proceeding-p2mp-mid-point-s2-ls { | | leaf proceeding-p2mp-mid-point-s2-ls { |
| type uint32; | | type uint32; |
| description | | description |
| "P2MP S2Ls in signalling=proceeding state at Mid"; | | "P2MP S2Ls in signalling=proceeding state at Mid"; |
| } | | } |
| leaf frr-p2mp-mid-point-s2-ls { | | leaf frr-p2mp-mid-point-s2-ls { |
| type uint32; | | type uint32; |
| description | | description |
| "P2MP S2Ls with FRR requested at Mid"; | | "P2MP S2Ls with FRR requested at Mid"; |
| } | | } |
| leaf protected-p2mp-mid-point-s2-ls { | | leaf protected-p2mp-mid-point-s2-ls { |
| type uint32; | | type uint32; |
| description | | description |
| "P2MP S2Ls FRR Protected at Mid"; | | "P2MP S2Ls FRR Protected at Mid"; |
| } | | } |
| leaf rerouted-p2mp-mid-point-s2-ls { | | leaf rerouted-p2mp-mid-point-s2-ls { |
| type uint32; | | type uint32; |
| description | | description |
| "P2MP S2Ls FRR Rerouted at Mid"; | | "P2MP S2Ls FRR Rerouted at Mid"; |
| } | | } |
| leaf p2mp-tail-s2-ls { | | leaf p2mp-tail-s2-ls { |
| type uint32; | | type uint32; |
| description | | description |
| "P2MP S2Ls at Tail"; | | "P2MP S2Ls at Tail"; |
| } | | } |
| leaf up-p2mp-tail-s2-ls { | | leaf up-p2mp-tail-s2-ls { |
| type uint32; | | type uint32; |
| description | | description |
| "P2MP S2Ls in Up state at Tail"; | | "P2MP S2Ls in Up state at Tail"; |
| } | | } |
| leaf bidir-head-tunnels { | | leaf bidir-head-tunnels { |
| type uint32; | | type uint32; |
| description | | description |
| "Bidirectional Head Tunnel interfaces"; | | "Bidirectional Head Tunnel interfaces"; |
| } | | } |
| leaf bidir-head-tunnels-up { | | leaf bidir-head-tunnels-up { |
| type uint32; | | type uint32; |
| description | | description |
| "Connected Bidirectional Head Tunnel interfaces"; | | "Connected Bidirectional Head Tunnel interfaces"; |
| } | | } |
| leaf bidir-head-tunnels-associated { | | leaf bidir-head-tunnels-associated { |
| type uint32; | | type uint32; |
| description | | description |
| "Associated Bidirectional Head Tunnels"; | | "Associated Bidirectional Head Tunnels"; |
| } | | } |
| leaf bidir-head-tunnels-corouted { | | leaf bidir-head-tunnels-corouted { |
| type uint32; | | type uint32; |
| description | | description |
| "Corouted Bidirectional Head Tunnels"; | | "Corouted Bidirectional Head Tunnels"; |
| } | | } |
| leaf bidir-head-ls-ps-up { | | leaf bidir-head-ls-ps-up { |
| type uint32; | | type uint32; |
| description | | description |
| "Connected Bidirectional Head Tunnel interfaces"; | | "Connected Bidirectional Head Tunnel interfaces"; |
| } | | } |
| leaf bidir-head-ls-ps-proceeding { | | leaf bidir-head-ls-ps-proceeding { |
| type uint32; | | type uint32; |
| description | | description |
| "Proceeding Bidirectional Head LSPs"; | | "Proceeding Bidirectional Head LSPs"; |
| } | | } |
| leaf bidir-head-ls-ps-associated { | | leaf bidir-head-ls-ps-associated { |
| type uint32; | | type uint32; |
| description | | description |
| "Associated Bidirectional Head LSPs"; | | "Associated Bidirectional Head LSPs"; |
| } | | } |
| leaf bidir-head-ls-ps-standby { | | leaf bidir-head-ls-ps-standby { |
| type uint32; | | type uint32; |
| description | | description |
| "Standby Bidirectional Head LSPs"; | | "Standby Bidirectional Head LSPs"; |
| } | | } |
| leaf bidir-mid-tunnels { | | leaf bidir-mid-tunnels { |
| type uint32; | | type uint32; |
| description | | description |
| "Bidirectional Mid Tunnel interfaces"; | | "Bidirectional Mid Tunnel interfaces"; |
| } | | } |
| leaf bidir-mid-tunnels-up { | | leaf bidir-mid-tunnels-up { |
| type uint32; | | type uint32; |
| description | | description |
| "Connected Bidirectional Mid Tunnel interfaces"; | | "Connected Bidirectional Mid Tunnel interfaces"; |
| } | | } |
| leaf bidir-mid-ls-ps-proceeding { | | leaf bidir-mid-ls-ps-proceeding { |
| type uint32; | | type uint32; |
| description | | description |
| "Proceeding Bidirectional Mid LSPs"; | | "Proceeding Bidirectional Mid LSPs"; |
| } | | } |
| leaf bidir-mid-ls-ps-associated { | | leaf bidir-mid-ls-ps-associated { |
| type uint32; | | type uint32; |
| description | | description |
| "Associated Bidirectional Mid LSPs"; | | "Associated Bidirectional Mid LSPs"; |
| } | | } |
| leaf bidir-mid-ls-ps-standby { | | leaf bidir-mid-ls-ps-standby { |
| type uint32; | | type uint32; |
| description | | description |
| "Standby Bidirectional Mid LSPs"; | | "Standby Bidirectional Mid LSPs"; |
| } | | } |
| leaf bidir-tail-ls-ps { | | leaf bidir-tail-ls-ps { |
| type uint32; | | type uint32; |
| description | | description |
| "Bidirectional Tail LSPs"; | | "Bidirectional Tail LSPs"; |
| } | | } |
| leaf bidir-tail-ls-ps-up { | | leaf bidir-tail-ls-ps-up { |
| type uint32; | | type uint32; |
| description | | description |
| "Connected Bidirectional Tail LSPs"; | | "Connected Bidirectional Tail LSPs"; |
| } | | } |
| leaf bidir-tail-ls-ps-proceeding { | | leaf bidir-tail-ls-ps-proceeding { |
| type uint32; | | type uint32; |
| description | | description |
| "Proceeding Bidirectional Tail LSPs"; | | "Proceeding Bidirectional Tail LSPs"; |
| } | | } |
| leaf bidir-tail-ls-ps-associated { | | leaf bidir-tail-ls-ps-associated { |
| type uint32; | | type uint32; |
| description | | description |
| "Associated Bidirectional Tail LSPs"; | | "Associated Bidirectional Tail LSPs"; |
| } | | } |
| leaf bidir-tail-ls-ps-standby { | | leaf bidir-tail-ls-ps-standby { |
| type uint32; | | type uint32; |
| description | | description |
| "Standby Bidirectional Tail LSPs"; | | "Standby Bidirectional Tail LSPs"; |
| } | | } |
| leaf bidir-tail-ls-ps-corouted { | | leaf bidir-tail-ls-ps-corouted { |
| type uint32; | | type uint32; |
| description | | description |
| "Corouted Bidirectional Tail LSPs"; | | "Corouted Bidirectional Tail LSPs"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-TUNNELS-AUTOBW-BRIEF { | | grouping MPLS-TE-TUNNELS-AUTOBW-BRIEF { |
| description | | description |
| "MPLS TE Tunnel AutoBandwidth Brief Information"; | | "MPLS TE Tunnel AutoBandwidth Brief Information"; |
| container auto-bandwidth-status { | | container auto-bandwidth-status { |
| description | | description |
| "Tunnels's AutoBandwidth Status information"; | | "Tunnels's AutoBandwidth Status information"; |
| uses MPLS-TE-TUNNELS-AUTOBW-STATUS; | | uses MPLS-TE-TUNNELS-AUTOBW-STATUS; |
| } | | } |
| leaf tunnel-name-xr { | | leaf tunnel-name-xr { |
| type string; | | type string; |
| description | | description |
| "Tunnel name"; | | "Tunnel name"; |
| } | | } |
| leaf signaled-name { | | leaf signaled-name { |
| type string; | | type string; |
| description | | description |
| "Tunnel signaled name"; | | "Tunnel signaled name"; |
| } | | } |
| leaf tunnel-lsp-id { | | leaf tunnel-lsp-id { |
| type uint32; | | type uint32; |
| description | | description |
| "Tunnel Lsp Id"; | | "Tunnel Lsp Id"; |
| } | | } |
| leaf bandwidth-applications { | | leaf bandwidth-applications { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of bandwidth applications requested | | "Total number of bandwidth applications requested |
| by auto-bw"; | | by auto-bw"; |
| } | | } |
| leaf last-bandwidth-applied { | | leaf last-bandwidth-applied { |
| type uint32; | | type uint32; |
| description | | description |
| "Last bandwidth requested by auto-bw for the | | "Last bandwidth requested by auto-bw for the |
| tunnel"; | | tunnel"; |
| } | | } |
| leaf tunnel-requested-bandwidth { | | leaf tunnel-requested-bandwidth { |
| type uint32; | | type uint32; |
| description | | description |
| "Requested Bandwidth for the tunnel"; | | "Requested Bandwidth for the tunnel"; |
| } | | } |
| leaf signalled-bandwidth { | | leaf signalled-bandwidth { |
| type uint32; | | type uint32; |
| description | | description |
| "Signalled bandwidth for the tunnel"; | | "Signalled bandwidth for the tunnel"; |
| } | | } |
| leaf highest-bandwidth { | | leaf highest-bandwidth { |
| type uint32; | | type uint32; |
| description | | description |
| "Highest bandwidth registered within current | | "Highest bandwidth registered within current |
| application period"; | | application period"; |
| } | | } |
| leaf last-sample-bandwidth { | | leaf last-sample-bandwidth { |
| type uint32; | | type uint32; |
| description | | description |
| "Last sample bandwidth collected"; | | "Last sample bandwidth collected"; |
| } | | } |
| leaf samples-collected { | | leaf samples-collected { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of samples collected within current | | "Number of samples collected within current |
| application period"; | | application period"; |
| } | | } |
| leaf time-left-application { | | leaf time-left-application { |
| type uint32; | | type uint32; |
| description | | description |
| "Time left until next auto-bw application | | "Time left until next auto-bw application |
| algorithm is performed"; | | algorithm is performed"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-FLEX-LSP-REV-LSP { | | grouping MPLS-TE-FLEX-LSP-REV-LSP { |
| description | | description |
| "MPLS TE Flex LSP Reverse LSP information"; | | "MPLS TE Flex LSP Reverse LSP information"; |
| container reverse-lsp-fec { | | container reverse-lsp-fec { |
| description | | description |
| "Reverse Associated Bidir LSP FEC"; | | "Reverse Associated Bidir LSP FEC"; |
| uses TE-LSP-FEC; | | uses TE-LSP-FEC; |
| } | | } |
| container association { | | container association { |
| description | | description |
| "Association Object"; | | "Association Object"; |
| uses MPLS-TE-S2L-ASSOCIATION-OBJECT; | | uses MPLS-TE-S2L-ASSOCIATION-OBJECT; |
| } | | } |
| container protection { | | container protection { |
| description | | description |
| "Protection Object"; | | "Protection Object"; |
| uses MPLS-TE-S2L-PROTECTION-OBJECT; | | uses MPLS-TE-S2L-PROTECTION-OBJECT; |
| } | | } |
| leaf reverse-lsp-present { | | leaf reverse-lsp-present { |
| type boolean; | | type boolean; |
| description | | description |
| "Reverse Associated Bidir LSP Present"; | | "Reverse Associated Bidir LSP Present"; |
| } | | } |
| leaf reverse-lsp-connected { | | leaf reverse-lsp-connected { |
| type boolean; | | type boolean; |
| description | | description |
| "Reverse Associated Bidir LSP Connected"; | | "Reverse Associated Bidir LSP Connected"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-FLEX-LSP-LSP { | | grouping MPLS-TE-FLEX-LSP-LSP { |
| description | | description |
| "MPLS TE FLEX LSP Information"; | | "MPLS TE FLEX LSP Information"; |
| container flex-info { | | container flex-info { |
| description | | description |
| "Flex Info"; | | "Flex Info"; |
| uses MPLS-TE-S2L-FLEX-INFO; | | uses MPLS-TE-S2L-FLEX-INFO; |
| } | | } |
| container association { | | container association { |
| description | | description |
| "Association Object"; | | "Association Object"; |
| uses MPLS-TE-S2L-ASSOCIATION-OBJECT; | | uses MPLS-TE-S2L-ASSOCIATION-OBJECT; |
| } | | } |
| container protection { | | container protection { |
| description | | description |
| "Protection Object"; | | "Protection Object"; |
| uses MPLS-TE-S2L-PROTECTION-OBJECT; | | uses MPLS-TE-S2L-PROTECTION-OBJECT; |
| } | | } |
| container reverse-lsp { | | container reverse-lsp { |
| description | | description |
| "Reverse LSP information"; | | "Reverse LSP information"; |
| uses MPLS-TE-FLEX-LSP-REV-LSP; | | uses MPLS-TE-FLEX-LSP-REV-LSP; |
| } | | } |
| leaf is-operational { | | leaf is-operational { |
| type boolean; | | type boolean; |
| description | | description |
| "Operational"; | | "Operational"; |
| } | | } |
| leaf lsp-uptime { | | leaf lsp-uptime { |
| type uint32; | | type uint32; |
| description | | description |
| "LSP Uptime"; | | "LSP Uptime"; |
| } | | } |
| leaf path-protection-lsp-id { | | leaf path-protection-lsp-id { |
| type uint32; | | type uint32; |
| description | | description |
| "LSP ID "; | | "LSP ID "; |
| } | | } |
| leaf lsp-mode { | | leaf lsp-mode { |
| type Mpls-te-lsp-mode; | | type Mpls-te-lsp-mode; |
| description | | description |
| "LSP mode"; | | "LSP mode"; |
| } | | } |
| leaf lsp-local-label { | | leaf lsp-local-label { |
| type uint32; | | type uint32; |
| description | | description |
| "Local label "; | | "Local label "; |
| } | | } |
| leaf lsp-output-interface { | | leaf lsp-output-interface { |
| type string; | | type string; |
| description | | description |
| "Output interface of LSP"; | | "Output interface of LSP"; |
| } | | } |
| leaf lsp-output-label { | | leaf lsp-output-label { |
| type uint32; | | type uint32; |
| description | | description |
| "Output label of the LSP"; | | "Output label of the LSP"; |
| } | | } |
| leaf lsp-state { | | leaf lsp-state { |
| type Mpls-te-tunnel-state; | | type Mpls-te-tunnel-state; |
| description | | description |
| "LSP State"; | | "LSP State"; |
| } | | } |
| list lsp-hop { | | list lsp-hop { |
| description | | description |
| "Path used by LSP"; | | "Path used by LSP"; |
| uses RSVP-MGMT-ERO-SUBOBJ; | | uses RSVP-MGMT-ERO-SUBOBJ; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-FLEX-LSP { | | grouping MPLS-TE-FLEX-LSP { |
| description | | description |
| "MPLS TE Flex LSP Information"; | | "MPLS TE Flex LSP Information"; |
| container working-lsp { | | container working-lsp { |
| description | | description |
| " Working LSP info"; | | " Working LSP info"; |
| uses MPLS-TE-FLEX-LSP-LSP; | | uses MPLS-TE-FLEX-LSP-LSP; |
| } | | } |
| container protect-lsp { | | container protect-lsp { |
| description | | description |
| " Protect LSP info"; | | " Protect LSP info"; |
| uses MPLS-TE-FLEX-LSP-LSP; | | uses MPLS-TE-FLEX-LSP-LSP; |
| } | | } |
| leaf is-tunnel-up { | | leaf is-tunnel-up { |
| type boolean; | | type boolean; |
| description | | description |
| "Tunnel UP"; | | "Tunnel UP"; |
| } | | } |
| leaf tun-id { | | leaf tun-id { |
| type uint16; | | type uint16; |
| description | | description |
| "Tunnel ID"; | | "Tunnel ID"; |
| } | | } |
| leaf source-address { | | leaf source-address { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Source"; | | "Source"; |
| } | | } |
| leaf destination-address { | | leaf destination-address { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Destination"; | | "Destination"; |
| } | | } |
| leaf extended-tunnel-id { | | leaf extended-tunnel-id { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Extended Tunnel ID"; | | "Extended Tunnel ID"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-FASTREROUTE-PROMOTION-BAG { | | grouping MPLS-TE-FASTREROUTE-PROMOTION-BAG { |
| description | | description |
| "MPLS TE Fast Reroute Promotion Information"; | | "MPLS TE Fast Reroute Promotion Information"; |
| leaf promotion-period { | | leaf promotion-period { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Promotion period in seconds"; | | "Promotion period in seconds"; |
| } | | } |
| leaf remaining-time { | | leaf remaining-time { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Remaining time for next promotion in seconds"; | | "Remaining time for next promotion in seconds"; |
| } | | } |
| leaf is-configured { | | leaf is-configured { |
| type boolean; | | type boolean; |
| description | | description |
| "Indicate if periodic promotion is configured "; | | "Indicate if periodic promotion is configured "; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-FASTREROUTE-PROTECTION-BAG { | | grouping MPLS-TE-FASTREROUTE-PROTECTION-BAG { |
| description | | description |
| "MPLS TE Fast Reroute Protected LSP Information"; | | "MPLS TE Fast Reroute Protected LSP Information"; |
| leaf source-address-xr { | | leaf source-address-xr { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Source"; | | "Source"; |
| } | | } |
| leaf destination-address-xr { | | leaf destination-address-xr { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Destination"; | | "Destination"; |
| } | | } |
| leaf tunnel-id-xr { | | leaf tunnel-id-xr { |
| type uint32; | | type uint32; |
| description | | description |
| "Tunnel ID"; | | "Tunnel ID"; |
| } | | } |
| leaf extended-tunnel-id-xr { | | leaf extended-tunnel-id-xr { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Extended Tunnel ID"; | | "Extended Tunnel ID"; |
| } | | } |
| leaf tunnel-name { | | leaf tunnel-name { |
| type string; | | type string; |
| description | | description |
| "Tunnel Name"; | | "Tunnel Name"; |
| } | | } |
| leaf tunnel-instance { | | leaf tunnel-instance { |
| type uint32; | | type uint32; |
| description | | description |
| "Tunnel instance"; | | "Tunnel instance"; |
| } | | } |
| leaf role { | | leaf role { |
| type Mpls-te-tunnel-role; | | type Mpls-te-tunnel-role; |
| description | | description |
| "Role of LSP"; | | "Role of LSP"; |
| } | | } |
| leaf admin-status { | | leaf admin-status { |
| type Mpls-te-tunnel-state; | | type Mpls-te-tunnel-state; |
| description | | description |
| "Tunnel Admin status"; | | "Tunnel Admin status"; |
| } | | } |
| leaf operation-status { | | leaf operation-status { |
| type Mpls-te-tunnel-state; | | type Mpls-te-tunnel-state; |
| description | | description |
| "Tunnel operational status"; | | "Tunnel operational status"; |
| } | | } |
| leaf is-signalled { | | leaf is-signalled { |
| type boolean; | | type boolean; |
| description | | description |
| "Indicates whether signalled"; | | "Indicates whether signalled"; |
| } | | } |
| leaf is-frr-requested { | | leaf is-frr-requested { |
| type boolean; | | type boolean; |
| description | | description |
| "TRUE if frr protection is on"; | | "TRUE if frr protection is on"; |
| } | | } |
| leaf outbound-frr-state { | | leaf outbound-frr-state { |
| type Mpls-te-frr-state; | | type Mpls-te-frr-state; |
| description | | description |
| "Indicates outbound FRR state"; | | "Indicates outbound FRR state"; |
| } | | } |
| leaf inbound-frr-state { | | leaf inbound-frr-state { |
| type Mpls-te-frr-state; | | type Mpls-te-frr-state; |
| description | | description |
| "Indicates inbound FRR state"; | | "Indicates inbound FRR state"; |
| } | | } |
| leaf output-interface-lsp { | | leaf output-interface-lsp { |
| type string; | | type string; |
| description | | description |
| "Output intface of the LSP"; | | "Output intface of the LSP"; |
| } | | } |
| leaf output-label { | | leaf output-label { |
| type uint32; | | type uint32; |
| description | | description |
| "Output label"; | | "Output label"; |
| } | | } |
| leaf next-hop-address { | | leaf next-hop-address { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Next hop"; | | "Next hop"; |
| } | | } |
| leaf frr-output-tunnel-interface { | | leaf frr-output-tunnel-interface { |
| type string; | | type string; |
| description | | description |
| "FRR output tunnel intface"; | | "FRR output tunnel intface"; |
| } | | } |
| leaf frr-output-label { | | leaf frr-output-label { |
| type uint32; | | type uint32; |
| description | | description |
| "FRR output label"; | | "FRR output label"; |
| } | | } |
| leaf backup-status { | | leaf backup-status { |
| type Mpls-te-backup-status; | | type Mpls-te-backup-status; |
| description | | description |
| "Backup status"; | | "Backup status"; |
| } | | } |
| leaf bandwidth-pool-type { | | leaf bandwidth-pool-type { |
| type Mpls-te-bw-pool; | | type Mpls-te-bw-pool; |
| description | | description |
| "Bandwidth pool type"; | | "Bandwidth pool type"; |
| } | | } |
| leaf bandwidth-limit-type { | | leaf bandwidth-limit-type { |
| type Mpls-te-bw-limit; | | type Mpls-te-bw-limit; |
| description | | description |
| "Bandwidth limit type"; | | "Bandwidth limit type"; |
| } | | } |
| leaf original-input-interface { | | leaf original-input-interface { |
| type string; | | type string; |
| description | | description |
| "Input intface of the LSP"; | | "Input intface of the LSP"; |
| } | | } |
| leaf input-label { | | leaf input-label { |
| type uint32; | | type uint32; |
| description | | description |
| "Input label"; | | "Input label"; |
| } | | } |
| leaf previous-hop-address { | | leaf previous-hop-address { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Previous hop"; | | "Previous hop"; |
| } | | } |
| leaf backup-bandwidth { | | leaf backup-bandwidth { |
| type uint32; | | type uint32; |
| description | | description |
| "Backup bandwidth"; | | "Backup bandwidth"; |
| } | | } |
| leaf frr-output-interface { | | leaf frr-output-interface { |
| type string; | | type string; |
| description | | description |
| "Output interface of bkup tunnel"; | | "Output interface of bkup tunnel"; |
| } | | } |
| leaf backup-next-hop-address { | | leaf backup-next-hop-address { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "S2L Nexthop of the backup tunnel"; | | "S2L Nexthop of the backup tunnel"; |
| } | | } |
| leaf lsp-bandwidth-type { | | leaf lsp-bandwidth-type { |
| type Mpls-te-bw-pool; | | type Mpls-te-bw-pool; |
| description | | description |
| "LSP bandwidth type"; | | "LSP bandwidth type"; |
| } | | } |
| leaf sharing-type { | | leaf sharing-type { |
| type Mpls-te-frr-sharing; | | type Mpls-te-frr-sharing; |
| description | | description |
| "Outgoing i/f Sharing type"; | | "Outgoing i/f Sharing type"; |
| } | | } |
| leaf is-p2mp-tunnel { | | leaf is-p2mp-tunnel { |
| type boolean; | | type boolean; |
| description | | description |
| "Is P2P or P2MP Tunnel"; | | "Is P2P or P2MP Tunnel"; |
| } | | } |
| leaf sub-group-original-id { | | leaf sub-group-original-id { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "S2L Sub-Group Originator ID"; | | "S2L Sub-Group Originator ID"; |
| } | | } |
| leaf sub-group-id-xr { | | leaf sub-group-id-xr { |
| type uint16; | | type uint16; |
| description | | description |
| "S2L Sub-Group ID"; | | "S2L Sub-Group ID"; |
| } | | } |
| leaf p2mp-id-xr { | | leaf p2mp-id-xr { |
| type uint32; | | type uint32; |
| description | | description |
| "S2L P2MP ID"; | | "S2L P2MP ID"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-FASTREROUTE-BAG { | | grouping MPLS-TE-FASTREROUTE-BAG { |
| description | | description |
| "MPLS TE Fast Reroute Information"; | | "MPLS TE Fast Reroute Information"; |
| leaf backup-tunnel-id { | | leaf backup-tunnel-id { |
| type uint32; | | type uint32; |
| description | | description |
| "Backup tunnel ID"; | | "Backup tunnel ID"; |
| } | | } |
| leaf backup-tunnel-name-xr { | | leaf backup-tunnel-name-xr { |
| type string; | | type string; |
| description | | description |
| "Backup tunnel name"; | | "Backup tunnel name"; |
| } | | } |
| leaf backup-status { | | leaf backup-status { |
| type Mpls-te-backup-status; | | type Mpls-te-backup-status; |
| description | | description |
| "Backup state"; | | "Backup state"; |
| } | | } |
| leaf backup-type { | | leaf backup-type { |
| type Mpls-te-backup; | | type Mpls-te-backup; |
| description | | description |
| "Backup type"; | | "Backup type"; |
| } | | } |
| leaf backup-usage { | | leaf backup-usage { |
| type Mpls-te-backup-usage; | | type Mpls-te-backup-usage; |
| description | | description |
| "Backup usage"; | | "Backup usage"; |
| } | | } |
| leaf prot-interface-autobackup-config { | | leaf prot-interface-autobackup-config { |
| type Auto-backup-protection; | | type Auto-backup-protection; |
| description | | description |
| "Protected interface Autobackup config"; | | "Protected interface Autobackup config"; |
| } | | } |
| leaf prot-interface-srlg-config { | | leaf prot-interface-srlg-config { |
| type Auto-backup-srlg-mode; | | type Auto-backup-srlg-mode; |
| description | | description |
| "Protected interface SRLG config"; | | "Protected interface SRLG config"; |
| } | | } |
| leaf tunnel-attribute-set-name { | | leaf tunnel-attribute-set-name { |
| type string; | | type string; |
| description | | description |
| "Attribute Set Name"; | | "Attribute Set Name"; |
| } | | } |
| leaf has-attribute-set { | | leaf has-attribute-set { |
| type boolean; | | type boolean; |
| description | | description |
| "TRUE if the auto-backup has an attribute set | | "TRUE if the auto-backup has an attribute set |
| defined"; | | defined"; |
| } | | } |
| leaf is-attribute-set-in-db { | | leaf is-attribute-set-in-db { |
| type boolean; | | type boolean; |
| description | | description |
| "Flag to indicate the existence of attribute set | | "Flag to indicate the existence of attribute set |
| found in database"; | | found in database"; |
| } | | } |
| leaf recreate-timer-is-running { | | leaf recreate-timer-is-running { |
| type boolean; | | type boolean; |
| description | | description |
| "Indicates if the recreate timer is running"; | | "Indicates if the recreate timer is running"; |
| } | | } |
| leaf recreate-remaining-time { | | leaf recreate-remaining-time { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Time Remaining in Recreate Timer (seconds)"; | | "Time Remaining in Recreate Timer (seconds)"; |
| } | | } |
| leaf source-address { | | leaf source-address { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Backup's source"; | | "Backup's source"; |
| } | | } |
| leaf destination-address { | | leaf destination-address { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Backup's destination"; | | "Backup's destination"; |
| } | | } |
| leaf general-status { | | leaf general-status { |
| type Mpls-te-tunnel-state; | | type Mpls-te-tunnel-state; |
| description | | description |
| "Backup's general status"; | | "Backup's general status"; |
| } | | } |
| leaf connection-status { | | leaf connection-status { |
| type Mpls-te-tunnel-state; | | type Mpls-te-tunnel-state; |
| description | | description |
| "Backup's connection's status"; | | "Backup's connection's status"; |
| } | | } |
| leaf output-interface-name { | | leaf output-interface-name { |
| type string; | | type string; |
| description | | description |
| "The output intf of the tunnel"; | | "The output intf of the tunnel"; |
| } | | } |
| leaf bandwidth-pool-type { | | leaf bandwidth-pool-type { |
| type Mpls-te-bw-pool; | | type Mpls-te-bw-pool; |
| description | | description |
| "Bandwidth pool type"; | | "Bandwidth pool type"; |
| } | | } |
| leaf bandwidth-limit-type { | | leaf bandwidth-limit-type { |
| type Mpls-te-bw-limit; | | type Mpls-te-bw-limit; |
| description | | description |
| "Bandwidth limit type"; | | "Bandwidth limit type"; |
| } | | } |
| leaf bandwidth { | | leaf bandwidth { |
| type uint32; | | type uint32; |
| units "kbit/s"; | | units "kbit/s"; |
| description | | description |
| "Bandwidth (kbps)"; | | "Bandwidth (kbps)"; |
| } | | } |
| leaf tunnel-instance { | | leaf tunnel-instance { |
| type uint32; | | type uint32; |
| description | | description |
| "Tunnel instance"; | | "Tunnel instance"; |
| } | | } |
| leaf in-use-bandwidth { | | leaf in-use-bandwidth { |
| type uint32; | | type uint32; |
| units "kbit/s"; | | units "kbit/s"; |
| description | | description |
| "Bandwidth currently in use (kbps)"; | | "Bandwidth currently in use (kbps)"; |
| } | | } |
| leaf soft-preempted-in-use-bandwidth { | | leaf soft-preempted-in-use-bandwidth { |
| type uint32; | | type uint32; |
| units "kbit/s"; | | units "kbit/s"; |
| description | | description |
| "Bandwidth soft preempted and rerouted over the | | "Bandwidth soft preempted and rerouted over the |
| backup(kbps)"; | | backup(kbps)"; |
| } | | } |
| leaf ls-ps { | | leaf ls-ps { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of LSPs"; | | "Number of LSPs"; |
| } | | } |
| leaf s2l-families { | | leaf s2l-families { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of S2L Families"; | | "Number of S2L Families"; |
| } | | } |
| leaf s2-ls { | | leaf s2-ls { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of P2MP S2Ls"; | | "Number of P2MP S2Ls"; |
| } | | } |
| leaf frr-active-ls-ps { | | leaf frr-active-ls-ps { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of LSPs in FRR active state"; | | "Number of LSPs in FRR active state"; |
| } | | } |
| leaf frr-active-soft-preempted-ls-ps { | | leaf frr-active-soft-preempted-ls-ps { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of soft preempted LSPs routed over backup"; | | "Number of soft preempted LSPs routed over backup"; |
| } | | } |
| n | leaf reoptimize-timer-frequency { | n | |
| type uint16; | | |
| units "second"; | | |
| description | | |
| "Reoptimize Timer frequency (seconds)"; | | |
| } | | |
| leaf reoptimize-timer-is-running { | | |
| type boolean; | | |
| description | | |
| "Indicates if the reoptimize timer is running"; | | |
| } | | |
| leaf reoptimize-remaining-time { | | |
| type uint16; | | |
| units "second"; | | |
| description | | |
| "Time Remaining in reoptimize Timer (seconds)"; | | |
| } | | |
| } | | } |
| | | |
| grouping TE-TUNNEL-AUTOROUTE-DEST { | | grouping TE-TUNNEL-AUTOROUTE-DEST { |
| description | | description |
| "TE TUNNEL AUTOROUTE DEST"; | | "TE TUNNEL AUTOROUTE DEST"; |
| leaf prefix-address { | | leaf prefix-address { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "PrefixAddress"; | | "PrefixAddress"; |
| } | | } |
| leaf prefix-length { | | leaf prefix-length { |
| type uint32; | | type uint32; |
| description | | description |
| "PrefixLength"; | | "PrefixLength"; |
| } | | } |
| leaf metric { | | leaf metric { |
| type uint32; | | type uint32; |
| description | | description |
| "Metric"; | | "Metric"; |
| } | | } |
| leaf install-time { | | leaf install-time { |
| type uint32; | | type uint32; |
| description | | description |
| "InstallTime"; | | "InstallTime"; |
| } | | } |
| leaf interface-handle { | | leaf interface-handle { |
| type xr:Interface-name; | | type xr:Interface-name; |
| description | | description |
| "InterfaceHandle"; | | "InterfaceHandle"; |
| } | | } |
| } | | } |
| | | |
| grouping TE-TUNNEL-AUTOROUTE-DESTINATIONS { | | grouping TE-TUNNEL-AUTOROUTE-DESTINATIONS { |
| description | | description |
| "TE TUNNEL AUTOROUTE DESTINATIONS"; | | "TE TUNNEL AUTOROUTE DESTINATIONS"; |
| leaf tunnel-id-xr { | | leaf tunnel-id-xr { |
| type uint16; | | type uint16; |
| description | | description |
| "tunnel id xr"; | | "tunnel id xr"; |
| } | | } |
| leaf tunnel-name { | | leaf tunnel-name { |
| type string; | | type string; |
| description | | description |
| "Tunnel name"; | | "Tunnel name"; |
| } | | } |
| list tunnel-autoroute-dest { | | list tunnel-autoroute-dest { |
| description | | description |
| "tunnel autoroute dest"; | | "tunnel autoroute dest"; |
| uses TE-TUNNEL-AUTOROUTE-DEST; | | uses TE-TUNNEL-AUTOROUTE-DEST; |
| } | | } |
| } | | } |
| | | |
| grouping TE-SYNC-STATUS-MASTER-INFO { | | grouping TE-SYNC-STATUS-MASTER-INFO { |
| description | | description |
| "Master Sync status information"; | | "Master Sync status information"; |
| container idt { | | container idt { |
| description | | description |
| "Sync status IDT information"; | | "Sync status IDT information"; |
| uses TE-SYNC-IDT-INFO; | | uses TE-SYNC-IDT-INFO; |
| } | | } |
| } | | } |
| | | |
| grouping TE-S2L-PENDING-INFO { | | grouping TE-S2L-PENDING-INFO { |
| description | | description |
| "Sync pending S2L information"; | | "Sync pending S2L information"; |
| leaf pending-reason { | | leaf pending-reason { |
| type Te-sync-pending-reason; | | type Te-sync-pending-reason; |
| description | | description |
| "Pending reason"; | | "Pending reason"; |
| } | | } |
| leaf signaled-name { | | leaf signaled-name { |
| type string; | | type string; |
| description | | description |
| "Signaled name"; | | "Signaled name"; |
| } | | } |
| leaf s2l-role { | | leaf s2l-role { |
| type Mpls-te-tunnel-role; | | type Mpls-te-tunnel-role; |
| description | | description |
| "S2L role"; | | "S2L role"; |
| } | | } |
| } | | } |
| | | |
| grouping TE-VIF-PENDING-INFO { | | grouping TE-VIF-PENDING-INFO { |
| description | | description |
| "Sync pending VIF information"; | | "Sync pending VIF information"; |
| leaf pending-reason { | | leaf pending-reason { |
| type Te-sync-pending-reason; | | type Te-sync-pending-reason; |
| description | | description |
| "Pending reason"; | | "Pending reason"; |
| } | | } |
| leaf tunnel-name { | | leaf tunnel-name { |
| type string; | | type string; |
| description | | description |
| "Tunnel name"; | | "Tunnel name"; |
| } | | } |
| } | | } |
| | | |
| grouping TE-IDT-STATUS { | | grouping TE-IDT-STATUS { |
| description | | description |
| "IDT status information"; | | "IDT status information"; |
| leaf is-ready-status { | | leaf is-ready-status { |
| type boolean; | | type boolean; |
| description | | description |
| "Ready status"; | | "Ready status"; |
| } | | } |
| leaf reason { | | leaf reason { |
| type Te-sync-not-ready-reason; | | type Te-sync-not-ready-reason; |
| description | | description |
| "Not ready reason"; | | "Not ready reason"; |
| } | | } |
| leaf idt-start-time { | | leaf idt-start-time { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "IDT start timestampe in seconds"; | | "IDT start timestampe in seconds"; |
| } | | } |
| leaf idt-end-time { | | leaf idt-end-time { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "IDT end timestampe in seconds"; | | "IDT end timestampe in seconds"; |
| } | | } |
| leaf declare-time { | | leaf declare-time { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Declare ready timestampe in seconds"; | | "Declare ready timestampe in seconds"; |
| } | | } |
| leaf withdraw-time { | | leaf withdraw-time { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Withdraw ready timestampe in seconds"; | | "Withdraw ready timestampe in seconds"; |
| } | | } |
| } | | } |
| | | |
| grouping TE-SYNC-IDT-INFO { | | grouping TE-SYNC-IDT-INFO { |
| description | | description |
| "Sync Status information"; | | "Sync Status information"; |
| container current-idt-info { | | container current-idt-info { |
| description | | description |
| "Current IDT information"; | | "Current IDT information"; |
| uses TE-IDT-STATUS; | | uses TE-IDT-STATUS; |
| } | | } |
| container previous-idt-status { | | container previous-idt-status { |
| description | | description |
| "Previous IDT information"; | | "Previous IDT information"; |
| uses TE-IDT-STATUS; | | uses TE-IDT-STATUS; |
| } | | } |
| } | | } |
| | | |
| grouping TE-SYNC-STATUS-SLAVE-INFO { | | grouping TE-SYNC-STATUS-SLAVE-INFO { |
| description | | description |
| "Sync status slave Information"; | | "Sync status slave Information"; |
| container idt { | | container idt { |
| description | | description |
| "Sync status IDT information"; | | "Sync status IDT information"; |
| uses TE-SYNC-IDT-INFO; | | uses TE-SYNC-IDT-INFO; |
| } | | } |
| leaf insync-tunnels { | | leaf insync-tunnels { |
| type uint32; | | type uint32; |
| description | | description |
| "Tunnels in sync"; | | "Tunnels in sync"; |
| } | | } |
| leaf insync-sub-ls-ps { | | leaf insync-sub-ls-ps { |
| type uint32; | | type uint32; |
| description | | description |
| "Sub-LSPs in sync"; | | "Sub-LSPs in sync"; |
| } | | } |
| leaf pending-tunnels { | | leaf pending-tunnels { |
| type uint32; | | type uint32; |
| description | | description |
| "Tunnels in sync pending"; | | "Tunnels in sync pending"; |
| } | | } |
| leaf pending-sub-ls-ps { | | leaf pending-sub-ls-ps { |
| type uint32; | | type uint32; |
| description | | description |
| "Sub-LSPs in sync pending"; | | "Sub-LSPs in sync pending"; |
| } | | } |
| list vif-pending { | | list vif-pending { |
| description | | description |
| "Pending tunnels details"; | | "Pending tunnels details"; |
| uses TE-VIF-PENDING-INFO; | | uses TE-VIF-PENDING-INFO; |
| } | | } |
| list s2l-pending { | | list s2l-pending { |
| description | | description |
| "Pending sub-LSPs details"; | | "Pending sub-LSPs details"; |
| uses TE-S2L-PENDING-INFO; | | uses TE-S2L-PENDING-INFO; |
| } | | } |
| } | | } |
| | | |
| grouping TE-SYNC-STATUS-INFO { | | grouping TE-SYNC-STATUS-INFO { |
| description | | description |
| "Sync information for the NSR and ISSU based on | | "Sync information for the NSR and ISSU based on |
| master or slave role"; | | master or slave role"; |
| container slave-sync-information { | | container slave-sync-information { |
| when "../sync-show-type = 'slave-sync-status-show'" { | | when "../sync-show-type = 'slave-sync-status-show'" { |
| description | | description |
| "../SyncShowType = 'SlaveSyncStatusShow'"; | | "../SyncShowType = 'SlaveSyncStatusShow'"; |
| } | | } |
| description | | description |
| "Slave sync information"; | | "Slave sync information"; |
| uses TE-SYNC-STATUS-SLAVE-INFO; | | uses TE-SYNC-STATUS-SLAVE-INFO; |
| } | | } |
| container master-sync-information { | | container master-sync-information { |
| when "../sync-show-type = 'master-sync-status-show'" { | | when "../sync-show-type = 'master-sync-status-show'" { |
| description | | description |
| "../SyncShowType = 'MasterSyncStatusShow'"; | | "../SyncShowType = 'MasterSyncStatusShow'"; |
| } | | } |
| description | | description |
| "Master sync information"; | | "Master sync information"; |
| uses TE-SYNC-STATUS-MASTER-INFO; | | uses TE-SYNC-STATUS-MASTER-INFO; |
| } | | } |
| leaf sync-show-type { | | leaf sync-show-type { |
| type Te-sync-status-show; | | type Te-sync-status-show; |
| description | | description |
| "SyncShowType"; | | "SyncShowType"; |
| } | | } |
| } | | } |
| | | |
| grouping TE-NSR-ISSU-STATUS-INFO { | | grouping TE-NSR-ISSU-STATUS-INFO { |
| description | | description |
| "NSR/ISSU sync status information"; | | "NSR/ISSU sync status information"; |
| container sync-status-information { | | container sync-status-information { |
| description | | description |
| "Sync information for the NSR and ISSU"; | | "Sync information for the NSR and ISSU"; |
| uses TE-SYNC-STATUS-INFO; | | uses TE-SYNC-STATUS-INFO; |
| } | | } |
| leaf role { | | leaf role { |
| type Te-proc-role; | | type Te-proc-role; |
| description | | description |
| "Process role"; | | "Process role"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-DSTE-CLASS { | | grouping MPLS-TE-DSTE-CLASS { |
| description | | description |
| "A DSTE class"; | | "A DSTE class"; |
| leaf class-number { | | leaf class-number { |
| type uint8; | | type uint8; |
| description | | description |
| "The DS-TE class number from 0 to 7"; | | "The DS-TE class number from 0 to 7"; |
| } | | } |
| leaf class-type { | | leaf class-type { |
| type uint8; | | type uint8; |
| description | | description |
| "The class type of the TE class"; | | "The class type of the TE class"; |
| } | | } |
| leaf priority { | | leaf priority { |
| type uint8; | | type uint8; |
| description | | description |
| "The priority of the TE class"; | | "The priority of the TE class"; |
| } | | } |
| leaf class-status { | | leaf class-status { |
| type Mpls-te-dste-class-status; | | type Mpls-te-dste-class-status; |
| description | | description |
| "The status of the TE class"; | | "The status of the TE class"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-DSTE-CLASSES { | | grouping MPLS-TE-DSTE-CLASSES { |
| description | | description |
| " A set of DSTE classes"; | | " A set of DSTE classes"; |
| list te-class { | | list te-class { |
| max-elements "8"; | | max-elements "8"; |
| description | | description |
| "te class"; | | "te class"; |
| uses MPLS-TE-DSTE-CLASS; | | uses MPLS-TE-DSTE-CLASS; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-TOPO-SRLG-LINK { | | grouping MPLS-TE-TOPO-SRLG-LINK { |
| description | | description |
| "SRLG link address data"; | | "SRLG link address data"; |
| container link-address-generic { | | container link-address-generic { |
| description | | description |
| "Link address"; | | "Link address"; |
| uses TE-ADDR; | | uses TE-ADDR; |
| } | | } |
| leaf link-address { | | leaf link-address { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Link address"; | | "Link address"; |
| } | | } |
| leaf te-router-id { | | leaf te-router-id { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Link TE router-id"; | | "Link TE router-id"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-TOPO-SRLG-AREA { | | grouping MPLS-TE-TOPO-SRLG-AREA { |
| description | | description |
| "A MPLS TE topology link in a SRLG"; | | "A MPLS TE topology link in a SRLG"; |
| leaf igp-type { | | leaf igp-type { |
| type Igp-protocol; | | type Igp-protocol; |
| description | | description |
| "IGP type"; | | "IGP type"; |
| } | | } |
| leaf igp-instance { | | leaf igp-instance { |
| type string; | | type string; |
| description | | description |
| "IGP Instance name"; | | "IGP Instance name"; |
| } | | } |
| leaf igp-area { | | leaf igp-area { |
| type uint32; | | type uint32; |
| description | | description |
| "IGP Area ID"; | | "IGP Area ID"; |
| } | | } |
| leaf igp-area-format { | | leaf igp-area-format { |
| type Igp-ospf-area-format; | | type Igp-ospf-area-format; |
| description | | description |
| "IGP-area format"; | | "IGP-area format"; |
| } | | } |
| list srlg-link { | | list srlg-link { |
| description | | description |
| "Links in this SRLG/area"; | | "Links in this SRLG/area"; |
| uses MPLS-TE-TOPO-SRLG-LINK; | | uses MPLS-TE-TOPO-SRLG-LINK; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-TOPO-SRLG { | | grouping MPLS-TE-TOPO-SRLG { |
| description | | description |
| "A SRLG entry in the MPLS TE topology"; | | "A SRLG entry in the MPLS TE topology"; |
| leaf srlg-name { | | leaf srlg-name { |
| type string; | | type string; |
| description | | description |
| "SRLG name"; | | "SRLG name"; |
| } | | } |
| leaf admin-weight { | | leaf admin-weight { |
| type uint32; | | type uint32; |
| description | | description |
| "The admin weight that is added to the link if | | "The admin weight that is added to the link if |
| the SRLG is shared with the protected link"; | | the SRLG is shared with the protected link"; |
| } | | } |
| list srlg-areas { | | list srlg-areas { |
| description | | description |
| "Topology areas in this SRLG"; | | "Topology areas in this SRLG"; |
| uses MPLS-TE-TOPO-SRLG-AREA; | | uses MPLS-TE-TOPO-SRLG-AREA; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-TOPO-CFG-SRLG-LINK { | | grouping MPLS-TE-TOPO-CFG-SRLG-LINK { |
| description | | description |
| "A link associated with configured SRLG"; | | "A link associated with configured SRLG"; |
| leaf local-address { | | leaf local-address { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Local address"; | | "Local address"; |
| } | | } |
| leaf remote-address { | | leaf remote-address { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Remote address"; | | "Remote address"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-TOPO-CFG-SRLG { | | grouping MPLS-TE-TOPO-CFG-SRLG { |
| description | | description |
| "A configured SRLG entry"; | | "A configured SRLG entry"; |
| leaf srlg-number-xr { | | leaf srlg-number-xr { |
| type uint32; | | type uint32; |
| description | | description |
| "SRLG number"; | | "SRLG number"; |
| } | | } |
| leaf srlg-name { | | leaf srlg-name { |
| type string; | | type string; |
| description | | description |
| "SRLG name"; | | "SRLG name"; |
| } | | } |
| leaf admin-weight { | | leaf admin-weight { |
| type uint32; | | type uint32; |
| description | | description |
| "The admin weight that is added to the link if | | "The admin weight that is added to the link if |
| the SRLG is shared with the protected link"; | | the SRLG is shared with the protected link"; |
| } | | } |
| leaf is-admin-weight-configured { | | leaf is-admin-weight-configured { |
| type boolean; | | type boolean; |
| description | | description |
| "Set to TRUE if the admin weight is explicitely | | "Set to TRUE if the admin weight is explicitely |
| configured"; | | configured"; |
| } | | } |
| list srlg-link { | | list srlg-link { |
| description | | description |
| "Link associated with the SRLG"; | | "Link associated with the SRLG"; |
| uses MPLS-TE-TOPO-CFG-SRLG-LINK; | | uses MPLS-TE-TOPO-CFG-SRLG-LINK; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-TOPOLOGY-PATH-BAG { | | grouping MPLS-TE-TOPOLOGY-PATH-BAG { |
| description | | description |
| "MPLS TE Topology Path Information"; | | "MPLS TE Topology Path Information"; |
| container affinity { | | container affinity { |
| description | | description |
| "Affinity"; | | "Affinity"; |
| uses MPLS-TE-TUNNELS-AFFINITY-INFO; | | uses MPLS-TE-TUNNELS-AFFINITY-INFO; |
| } | | } |
| leaf tunnel-id-xr { | | leaf tunnel-id-xr { |
| type uint32; | | type uint32; |
| description | | description |
| "The tunnel ID to which this path belong"; | | "The tunnel ID to which this path belong"; |
| } | | } |
| leaf destination-address-xr { | | leaf destination-address-xr { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "The path's destination"; | | "The path's destination"; |
| } | | } |
| leaf is-partial-path { | | leaf is-partial-path { |
| type boolean; | | type boolean; |
| description | | description |
| "TRUE if path is partial"; | | "TRUE if path is partial"; |
| } | | } |
| leaf is-full-path { | | leaf is-full-path { |
| type boolean; | | type boolean; |
| description | | description |
| "TRUE if path is full"; | | "TRUE if path is full"; |
| } | | } |
| leaf is-topology-checked { | | leaf is-topology-checked { |
| type boolean; | | type boolean; |
| description | | description |
| "TRUE if checking the topology is enabled"; | | "TRUE if checking the topology is enabled"; |
| } | | } |
| leaf is-segment-routing-db-checked { | | leaf is-segment-routing-db-checked { |
| type boolean; | | type boolean; |
| description | | description |
| "TRUE if checking the Segment-Routing DB is | | "TRUE if checking the Segment-Routing DB is |
| enabled"; | | enabled"; |
| } | | } |
| leaf requested-bandwidth { | | leaf requested-bandwidth { |
| type uint64; | | type uint64; |
| description | | description |
| "The path's requested bandwidth"; | | "The path's requested bandwidth"; |
| } | | } |
| leaf bandwidth-type { | | leaf bandwidth-type { |
| type uint64; | | type uint64; |
| description | | description |
| "The path's bandwidth type"; | | "The path's bandwidth type"; |
| } | | } |
| leaf mininum-bandwidth { | | leaf mininum-bandwidth { |
| type uint64; | | type uint64; |
| description | | description |
| "The path's minimum bandwidth"; | | "The path's minimum bandwidth"; |
| } | | } |
| leaf accumulated-admin-weight { | | leaf accumulated-admin-weight { |
| type uint64; | | type uint64; |
| description | | description |
| "The path's accumulated admin weight"; | | "The path's accumulated admin weight"; |
| } | | } |
| leaf setup-priority-xr { | | leaf setup-priority-xr { |
| type uint32; | | type uint32; |
| description | | description |
| "The path's setup priority"; | | "The path's setup priority"; |
| } | | } |
| leaf hold-priority-xr { | | leaf hold-priority-xr { |
| type uint32; | | type uint32; |
| description | | description |
| "The path's hold priority"; | | "The path's hold priority"; |
| } | | } |
| leaf node-hop-count { | | leaf node-hop-count { |
| type uint8; | | type uint8; |
| description | | description |
| "Path hop count"; | | "Path hop count"; |
| } | | } |
| leaf exclude-srlg-address { | | leaf exclude-srlg-address { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "The Exclude SRLG IP Addr"; | | "The Exclude SRLG IP Addr"; |
| } | | } |
| list hop { | | list hop { |
| description | | description |
| "The path's array of hops"; | | "The path's array of hops"; |
| leaf entry { | | leaf entry { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "The path's array of hops"; | | "The path's array of hops"; |
| } | | } |
| } | | } |
| list shared-risk-link-group { | | list shared-risk-link-group { |
| description | | description |
| "The path's excluded srlg groups"; | | "The path's excluded srlg groups"; |
| uses MPLS-SRLG-INFO; | | uses MPLS-SRLG-INFO; |
| } | | } |
| list sr-segment { | | list sr-segment { |
| description | | description |
| "The path's array of Segment-Routing segments"; | | "The path's array of Segment-Routing segments"; |
| uses TE-S2L-SR-PATH-HOP; | | uses TE-S2L-SR-PATH-HOP; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-AREA-INFO { | | grouping MPLS-TE-AREA-INFO { |
| description | | description |
| "Global information for an MPLS-TE area"; | | "Global information for an MPLS-TE area"; |
| container local-sid-and-srbg { | | container local-sid-and-srbg { |
| description | | description |
| "Local SID and SRBG"; | | "Local SID and SRBG"; |
| uses TE-SR-NODE-INFO; | | uses TE-SR-NODE-INFO; |
| } | | } |
| leaf protocol { | | leaf protocol { |
| type Igp-protocol; | | type Igp-protocol; |
| description | | description |
| "Protocol used"; | | "Protocol used"; |
| } | | } |
| leaf node-id { | | leaf node-id { |
| type string; | | type string; |
| description | | description |
| "The node's IGP id"; | | "The node's IGP id"; |
| } | | } |
| leaf area-id { | | leaf area-id { |
| type string; | | type string; |
| description | | description |
| "The area's id"; | | "The area's id"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-TOPOLOGY-GLOBAL-INFO-BAG { | | grouping MPLS-TE-TOPOLOGY-GLOBAL-INFO-BAG { |
| description | | description |
| "MPLS TE Topology Global Information"; | | "MPLS TE Topology Global Information"; |
| leaf hold-down-interval { | | leaf hold-down-interval { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Interval in seconds to hold down a neighbor | | "Interval in seconds to hold down a neighbor |
| after a signalling error"; | | after a signalling error"; |
| } | | } |
| leaf link-add-remove-count { | | leaf link-add-remove-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Link add/remove counter"; | | "Link add/remove counter"; |
| } | | } |
| leaf local-model-id { | | leaf local-model-id { |
| type uint32; | | type uint32; |
| description | | description |
| "Local BC Model ID"; | | "Local BC Model ID"; |
| } | | } |
| list areas { | | list areas { |
| description | | description |
| "Information for areas"; | | "Information for areas"; |
| uses MPLS-TE-AREA-INFO; | | uses MPLS-TE-AREA-INFO; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-LSP-WRAP-PROTECTION-BAG { | | grouping MPLS-TE-LSP-WRAP-PROTECTION-BAG { |
| description | | description |
| "MPLS TE LSP Wrap Protected LSP Information"; | | "MPLS TE LSP Wrap Protected LSP Information"; |
| leaf source-address-xr { | | leaf source-address-xr { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Source"; | | "Source"; |
| } | | } |
| leaf destination-address-xr { | | leaf destination-address-xr { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Destination"; | | "Destination"; |
| } | | } |
| leaf tunnel-id-xr { | | leaf tunnel-id-xr { |
| type uint16; | | type uint16; |
| description | | description |
| "Tunnel ID"; | | "Tunnel ID"; |
| } | | } |
| leaf extended-tunnel-id-xr { | | leaf extended-tunnel-id-xr { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Extended Tunnel ID"; | | "Extended Tunnel ID"; |
| } | | } |
| leaf tunnel-name { | | leaf tunnel-name { |
| type string; | | type string; |
| description | | description |
| "Tunnel Name"; | | "Tunnel Name"; |
| } | | } |
| leaf tunnel-instance { | | leaf tunnel-instance { |
| type uint32; | | type uint32; |
| description | | description |
| "Tunnel instance"; | | "Tunnel instance"; |
| } | | } |
| leaf lsp-wrap-protection-enable { | | leaf lsp-wrap-protection-enable { |
| type boolean; | | type boolean; |
| description | | description |
| "LSP Wrap protection enabled"; | | "LSP Wrap protection enabled"; |
| } | | } |
| leaf lsp-wrap-protection-label { | | leaf lsp-wrap-protection-label { |
| type uint32; | | type uint32; |
| description | | description |
| "LSP Wrap Merge Point Label"; | | "LSP Wrap Merge Point Label"; |
| } | | } |
| leaf reverse-egress-interface { | | leaf reverse-egress-interface { |
| type string; | | type string; |
| description | | description |
| "Reverse Egress Interface"; | | "Reverse Egress Interface"; |
| } | | } |
| leaf reverse-lsp-label { | | leaf reverse-lsp-label { |
| type uint32; | | type uint32; |
| description | | description |
| "Reverse LSP label"; | | "Reverse LSP label"; |
| } | | } |
| leaf lsp-wrap-protection-state { | | leaf lsp-wrap-protection-state { |
| type Mpls-te-lsp-wrap-state; | | type Mpls-te-lsp-wrap-state; |
| description | | description |
| "LSP wrap protection state"; | | "LSP wrap protection state"; |
| } | | } |
| leaf sub-group-original-id { | | leaf sub-group-original-id { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "S2L Sub-Group Originator ID"; | | "S2L Sub-Group Originator ID"; |
| } | | } |
| leaf sub-group-id-xr { | | leaf sub-group-id-xr { |
| type uint16; | | type uint16; |
| description | | description |
| "S2L Sub-Group ID"; | | "S2L Sub-Group ID"; |
| } | | } |
| leaf p2mp-id-xr { | | leaf p2mp-id-xr { |
| type uint32; | | type uint32; |
| description | | description |
| "S2L P2MP ID"; | | "S2L P2MP ID"; |
| } | | } |
| } | | } |
| | | |
| grouping TE-NEXTHOP-PATH { | | grouping TE-NEXTHOP-PATH { |
| description | | description |
| "TE NEXTHOP PATH"; | | "TE NEXTHOP PATH"; |
| leaf interface { | | leaf interface { |
| type xr:Interface-name; | | type xr:Interface-name; |
| description | | description |
| "Interface"; | | "Interface"; |
| } | | } |
| leaf address { | | leaf address { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Address"; | | "Address"; |
| } | | } |
| leaf abr-address { | | leaf abr-address { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "ABRAddress"; | | "ABRAddress"; |
| } | | } |
| } | | } |
| | | |
| grouping TE-RIB-ROUTE-BAG { | | grouping TE-RIB-ROUTE-BAG { |
| description | | description |
| "TE RIB ROUTE BAG"; | | "TE RIB ROUTE BAG"; |
| leaf route-protocol-name { | | leaf route-protocol-name { |
| type string; | | type string; |
| description | | description |
| "RouteProtocolName"; | | "RouteProtocolName"; |
| } | | } |
| leaf route-distance { | | leaf route-distance { |
| type uint32; | | type uint32; |
| description | | description |
| "RouteDistance"; | | "RouteDistance"; |
| } | | } |
| leaf route-metric { | | leaf route-metric { |
| type uint32; | | type uint32; |
| description | | description |
| "RouteMetric"; | | "RouteMetric"; |
| } | | } |
| leaf last-update-time { | | leaf last-update-time { |
| type uint32; | | type uint32; |
| description | | description |
| "LastUpdateTime"; | | "LastUpdateTime"; |
| } | | } |
| leaf is-registered { | | leaf is-registered { |
| type boolean; | | type boolean; |
| description | | description |
| "IsRegistered"; | | "IsRegistered"; |
| } | | } |
| leaf is-stale { | | leaf is-stale { |
| type boolean; | | type boolean; |
| description | | description |
| "IsStale"; | | "IsStale"; |
| } | | } |
| leaf is-default { | | leaf is-default { |
| type boolean; | | type boolean; |
| description | | description |
| "IsDefault"; | | "IsDefault"; |
| } | | } |
| leaf is-connected { | | leaf is-connected { |
| type boolean; | | type boolean; |
| description | | description |
| "IsConnected"; | | "IsConnected"; |
| } | | } |
| leaf is-populated { | | leaf is-populated { |
| type boolean; | | type boolean; |
| description | | description |
| "IsPopulated"; | | "IsPopulated"; |
| } | | } |
| leaf route-type { | | leaf route-type { |
| type uint16; | | type uint16; |
| description | | description |
| "RouteType"; | | "RouteType"; |
| } | | } |
| list next-hop-path { | | list next-hop-path { |
| description | | description |
| "next hop path"; | | "next hop path"; |
| uses TE-NEXTHOP-PATH; | | uses TE-NEXTHOP-PATH; |
| } | | } |
| } | | } |
| | | |
| grouping TE-TUNNEL-PATH { | | grouping TE-TUNNEL-PATH { |
| description | | description |
| "TE TUNNEL PATH"; | | "TE TUNNEL PATH"; |
| leaf tunnel-id { | | leaf tunnel-id { |
| type uint16; | | type uint16; |
| description | | description |
| "TunnelID"; | | "TunnelID"; |
| } | | } |
| leaf interface-handle { | | leaf interface-handle { |
| type xr:Interface-name; | | type xr:Interface-name; |
| description | | description |
| "InterfaceHandle"; | | "InterfaceHandle"; |
| } | | } |
| leaf install-time { | | leaf install-time { |
| type uint32; | | type uint32; |
| description | | description |
| "InstallTime"; | | "InstallTime"; |
| } | | } |
| leaf installed-metric { | | leaf installed-metric { |
| type uint32; | | type uint32; |
| description | | description |
| "InstalledMetric"; | | "InstalledMetric"; |
| } | | } |
| } | | } |
| | | |
| grouping TE-NEXTHOP-ROUTE { | | grouping TE-NEXTHOP-ROUTE { |
| description | | description |
| "TE NEXTHOP ROUTE"; | | "TE NEXTHOP ROUTE"; |
| container active-route { | | container active-route { |
| description | | description |
| "active route"; | | "active route"; |
| uses TE-RIB-ROUTE-BAG; | | uses TE-RIB-ROUTE-BAG; |
| } | | } |
| container backup-route { | | container backup-route { |
| description | | description |
| "backup route"; | | "backup route"; |
| uses TE-RIB-ROUTE-BAG; | | uses TE-RIB-ROUTE-BAG; |
| } | | } |
| leaf prefix-address-xr { | | leaf prefix-address-xr { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "prefix address xr"; | | "prefix address xr"; |
| } | | } |
| leaf prefix-length-xr { | | leaf prefix-length-xr { |
| type uint32; | | type uint32; |
| description | | description |
| "prefix length xr"; | | "prefix length xr"; |
| } | | } |
| leaf exact-match { | | leaf exact-match { |
| type boolean; | | type boolean; |
| description | | description |
| "ExactMatch"; | | "ExactMatch"; |
| } | | } |
| leaf create-time { | | leaf create-time { |
| type uint32; | | type uint32; |
| description | | description |
| "CreateTime"; | | "CreateTime"; |
| } | | } |
| leaf last-used-time { | | leaf last-used-time { |
| type uint32; | | type uint32; |
| description | | description |
| "LastUsedTime"; | | "LastUsedTime"; |
| } | | } |
| leaf expire-time { | | leaf expire-time { |
| type uint32; | | type uint32; |
| description | | description |
| "ExpireTime"; | | "ExpireTime"; |
| } | | } |
| leaf installed-tunnel-path-num { | | leaf installed-tunnel-path-num { |
| type uint32; | | type uint32; |
| description | | description |
| "InstalledTunnelPathNum"; | | "InstalledTunnelPathNum"; |
| } | | } |
| list tunnel-path { | | list tunnel-path { |
| description | | description |
| "tunnel path"; | | "tunnel path"; |
| uses TE-TUNNEL-PATH; | | uses TE-TUNNEL-PATH; |
| } | | } |
| } | | } |
| | | |
| grouping TE-SH-IGP-AREA-STATS { | | grouping TE-SH-IGP-AREA-STATS { |
| description | | description |
| "Statistics for an IGP-area"; | | "Statistics for an IGP-area"; |
| leaf area-adjacency-request-messages { | | leaf area-adjacency-request-messages { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of adjacency request messages sent"; | | "Number of adjacency request messages sent"; |
| } | | } |
| leaf area-adjacency-announce-messages { | | leaf area-adjacency-announce-messages { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of adjacency announcement messages | | "Number of adjacency announcement messages |
| received"; | | received"; |
| } | | } |
| leaf area-flood-messages { | | leaf area-flood-messages { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of local LSA floods sent"; | | "Number of local LSA floods sent"; |
| } | | } |
| leaf area-lsa-announce-messages { | | leaf area-lsa-announce-messages { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of LSA announcement messages received"; | | "Number of LSA announcement messages received"; |
| } | | } |
| leaf area-lsa-fragment-announce-messages { | | leaf area-lsa-fragment-announce-messages { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of LSA fragment announcement messages | | "Number of LSA fragment announcement messages |
| received"; | | received"; |
| } | | } |
| leaf area-lsa-delete-messages { | | leaf area-lsa-delete-messages { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of LSA delete messages received"; | | "Number of LSA delete messages received"; |
| } | | } |
| leaf area-lsa-fragment-delete-messages { | | leaf area-lsa-fragment-delete-messages { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of LSA fragment delete messages received"; | | "Number of LSA fragment delete messages received"; |
| } | | } |
| leaf area-tunnel-announce-messages { | | leaf area-tunnel-announce-messages { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of tunnel announcement messages sent"; | | "Number of tunnel announcement messages sent"; |
| } | | } |
| } | | } |
| | | |
| grouping TE-SH-IGP-AREA-ACTIVE { | | grouping TE-SH-IGP-AREA-ACTIVE { |
| description | | description |
| "Data relating to an active IGP area"; | | "Data relating to an active IGP area"; |
| container area-statistics { | | container area-statistics { |
| description | | description |
| "Area communication statistics"; | | "Area communication statistics"; |
| uses TE-SH-IGP-AREA-STATS; | | uses TE-SH-IGP-AREA-STATS; |
| } | | } |
| leaf interfaces-count { | | leaf interfaces-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of interfaces running over this area"; | | "Number of interfaces running over this area"; |
| } | | } |
| leaf link-idt-received { | | leaf link-idt-received { |
| type boolean; | | type boolean; |
| description | | description |
| "Flag to indicate IDT for link adjacencies was | | "Flag to indicate IDT for link adjacencies was |
| received"; | | received"; |
| } | | } |
| leaf topology-idt-received { | | leaf topology-idt-received { |
| type boolean; | | type boolean; |
| description | | description |
| "Flag to indicate IDT topology was received"; | | "Flag to indicate IDT topology was received"; |
| } | | } |
| leaf sr-strict { | | leaf sr-strict { |
| type boolean; | | type boolean; |
| description | | description |
| "Flag to indicate if the area is SR strict"; | | "Flag to indicate if the area is SR strict"; |
| } | | } |
| leaf p2p-heads-count { | | leaf p2p-heads-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of p2p tunnel heads whose path was | | "Number of p2p tunnel heads whose path was |
| calculated over this area"; | | calculated over this area"; |
| } | | } |
| leaf p2p-autoroute-announced-count { | | leaf p2p-autoroute-announced-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of p2p tunnel heads which have been | | "Number of p2p tunnel heads which have been |
| autoroute-announced into this area"; | | autoroute-announced into this area"; |
| } | | } |
| leaf p2p-forwarding-adjacency-count { | | leaf p2p-forwarding-adjacency-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of p2p tunnel heads which have been | | "Number of p2p tunnel heads which have been |
| announced as forwarding adjacencies in this area"; | | announced as forwarding adjacencies in this area"; |
| } | | } |
| leaf p2mp-destination-count { | | leaf p2mp-destination-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of P2MP destinations whose path was | | "Number of P2MP destinations whose path was |
| calculated over this area"; | | calculated over this area"; |
| } | | } |
| leaf tunnel-loose-hops { | | leaf tunnel-loose-hops { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of tunnels with a loose hop ERO expanded | | "Number of tunnels with a loose hop ERO expanded |
| in this area"; | | in this area"; |
| } | | } |
| } | | } |
| | | |
| grouping TE-SH-IGP-AREA { | | grouping TE-SH-IGP-AREA { |
| description | | description |
| "An IGP area"; | | "An IGP area"; |
| container active-data { | | container active-data { |
| description | | description |
| "Data which applies only to an active area"; | | "Data which applies only to an active area"; |
| uses TE-SH-IGP-AREA-ACTIVE; | | uses TE-SH-IGP-AREA-ACTIVE; |
| } | | } |
| leaf area-index { | | leaf area-index { |
| type uint32; | | type uint32; |
| description | | description |
| "Internal area index"; | | "Internal area index"; |
| } | | } |
| leaf area-number { | | leaf area-number { |
| type uint32; | | type uint32; |
| description | | description |
| "Area number"; | | "Area number"; |
| } | | } |
| leaf area-format { | | leaf area-format { |
| type Igp-ospf-area-format; | | type Igp-ospf-area-format; |
| description | | description |
| "IGP Area Format"; | | "IGP Area Format"; |
| } | | } |
| leaf is-config-ready { | | leaf is-config-ready { |
| type boolean; | | type boolean; |
| description | | description |
| "Indicates whether or not the area is correctly | | "Indicates whether or not the area is correctly |
| configured under the IGP submode to run TE"; | | configured under the IGP submode to run TE"; |
| } | | } |
| } | | } |
| | | |
| grouping TE-SH-IGP { | | grouping TE-SH-IGP { |
| description | | description |
| "An IGP instance"; | | "An IGP instance"; |
| leaf igp-type { | | leaf igp-type { |
| type Igp-protocol; | | type Igp-protocol; |
| description | | description |
| "IGP type"; | | "IGP type"; |
| } | | } |
| leaf instance-name { | | leaf instance-name { |
| type string; | | type string; |
| description | | description |
| " The IGP instance name"; | | " The IGP instance name"; |
| } | | } |
| leaf igp-system-id { | | leaf igp-system-id { |
| type string; | | type string; |
| description | | description |
| " The IGP instance's system/router-id; interpret | | " The IGP instance's system/router-id; interpret |
| appropriately depending on IGP type"; | | appropriately depending on IGP type"; |
| } | | } |
| leaf configured-te-router-id { | | leaf configured-te-router-id { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Configured TE router-id"; | | "Configured TE router-id"; |
| } | | } |
| leaf global-router-id { | | leaf global-router-id { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Global router-id"; | | "Global router-id"; |
| } | | } |
| leaf globall-router-id-optical { | | leaf globall-router-id-optical { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Global router-id for GMPLS (optical TE)"; | | "Global router-id for GMPLS (optical TE)"; |
| } | | } |
| leaf in-use-te-router-id { | | leaf in-use-te-router-id { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "TE router-id in use"; | | "TE router-id in use"; |
| } | | } |
| leaf is-connection-up { | | leaf is-connection-up { |
| type boolean; | | type boolean; |
| description | | description |
| "Flag to indicate whether the IGP connection is | | "Flag to indicate whether the IGP connection is |
| open or not"; | | open or not"; |
| } | | } |
| leaf connection-up-count { | | leaf connection-up-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of times IGP connection has gone up"; | | "Number of times IGP connection has gone up"; |
| } | | } |
| leaf connection-down-count { | | leaf connection-down-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of times IGP connection has gone down"; | | "Number of times IGP connection has gone down"; |
| } | | } |
| list secondary-router-id { | | list secondary-router-id { |
| description | | description |
| "Secondary router-ids"; | | "Secondary router-ids"; |
| leaf entry { | | leaf entry { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Secondary router-ids"; | | "Secondary router-ids"; |
| } | | } |
| } | | } |
| list area { | | list area { |
| description | | description |
| "IGP area information"; | | "IGP area information"; |
| uses TE-SH-IGP-AREA; | | uses TE-SH-IGP-AREA; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-FWD-ADJ-INFO { | | grouping MPLS-TE-FWD-ADJ-INFO { |
| description | | description |
| "A forwarding-adjacency"; | | "A forwarding-adjacency"; |
| leaf tunnel-name { | | leaf tunnel-name { |
| type string; | | type string; |
| description | | description |
| "The tunnel name"; | | "The tunnel name"; |
| } | | } |
| leaf traffic-share { | | leaf traffic-share { |
| type uint32; | | type uint32; |
| description | | description |
| "Traffic Share"; | | "Traffic Share"; |
| } | | } |
| leaf hold-time { | | leaf hold-time { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Hold time in seconds"; | | "Hold time in seconds"; |
| } | | } |
| leaf is-adjacency-up { | | leaf is-adjacency-up { |
| type boolean; | | type boolean; |
| description | | description |
| "True if adj is up"; | | "True if adj is up"; |
| } | | } |
| n | leaf igp-metric { | n | |
| type uint32; | | |
| description | | |
| "FA Metric configured for this tunnel"; | | |
| } | | |
| list ig-ps { | | list ig-ps { |
| description | | description |
| "List of IGPs to which it is announced"; | | "List of IGPs to which it is announced"; |
| uses MPLS-TE-AREA-AFI-INFO; | | uses MPLS-TE-AREA-AFI-INFO; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-FWD-ADJ-BAG { | | grouping MPLS-TE-FWD-ADJ-BAG { |
| description | | description |
| " A list of forwarding-adjacencies"; | | " A list of forwarding-adjacencies"; |
| leaf adjacencies { | | leaf adjacencies { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of Forwarding Adjacencies"; | | "Number of Forwarding Adjacencies"; |
| } | | } |
| leaf ipv6-adjacencies { | | leaf ipv6-adjacencies { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of IPv6 Forwarding Adjacencies"; | | "Number of IPv6 Forwarding Adjacencies"; |
| } | | } |
| leaf destination-address-xr { | | leaf destination-address-xr { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "The tunnel destination"; | | "The tunnel destination"; |
| } | | } |
| list forward-adjacency { | | list forward-adjacency { |
| description | | description |
| "Forwarding-adjacency list"; | | "Forwarding-adjacency list"; |
| uses MPLS-TE-FWD-ADJ-INFO; | | uses MPLS-TE-FWD-ADJ-INFO; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-AUTOTUN-BACKUP-CONFIG-INFO { | | grouping MPLS-TE-AUTOTUN-BACKUP-CONFIG-INFO { |
| description | | description |
| "Auto-tunnel backup feature configuration | | "Auto-tunnel backup feature configuration |
| information"; | | information"; |
| leaf is-configured { | | leaf is-configured { |
| type boolean; | | type boolean; |
| description | | description |
| "Indicate if auto-tunnel bacukp feature is | | "Indicate if auto-tunnel bacukp feature is |
| configured "; | | configured "; |
| } | | } |
| leaf interface-count { | | leaf interface-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of TE link interfaces with auto-tunnel | | "Number of TE link interfaces with auto-tunnel |
| backup configured"; | | backup configured"; |
| } | | } |
| leaf unused-removal-timeout-configured { | | leaf unused-removal-timeout-configured { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Configured value of unused removal timer in | | "Configured value of unused removal timer in |
| seconds"; | | seconds"; |
| } | | } |
| leaf min-tunnel-id { | | leaf min-tunnel-id { |
| type uint16; | | type uint16; |
| description | | description |
| "Lower bound of configured tunnel ID range"; | | "Lower bound of configured tunnel ID range"; |
| } | | } |
| leaf max-tunnel-id { | | leaf max-tunnel-id { |
| type uint16; | | type uint16; |
| description | | description |
| "Upper bound of configured tunnel ID range"; | | "Upper bound of configured tunnel ID range"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-AUTOTUN-BACKUP-SUMMARY-INFO { | | grouping MPLS-TE-AUTOTUN-BACKUP-SUMMARY-INFO { |
| description | | description |
| "Autotunnel backup summary information"; | | "Autotunnel backup summary information"; |
| leaf autobackups { | | leaf autobackups { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of autobackup tunnels"; | | "Total number of autobackup tunnels"; |
| } | | } |
| leaf up-autobackups { | | leaf up-autobackups { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of autobackup tunnels that are up"; | | "Total number of autobackup tunnels that are up"; |
| } | | } |
| leaf down-autobackups { | | leaf down-autobackups { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of autobackup tunnels that are down"; | | "Total number of autobackup tunnels that are down"; |
| } | | } |
| leaf unused-autobackups { | | leaf unused-autobackups { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of autobackup tunnels that are | | "Total number of autobackup tunnels that are |
| unused"; | | unused"; |
| } | | } |
| leaf next-hop-autobackups { | | leaf next-hop-autobackups { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of autobackup tunnels that are NHOP"; | | "Total number of autobackup tunnels that are NHOP"; |
| } | | } |
| leaf next-next-hop-autobackups { | | leaf next-next-hop-autobackups { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of autobackup tunnels that are | | "Total number of autobackup tunnels that are |
| NNHOP"; | | NNHOP"; |
| } | | } |
| leaf srlg-strict-autobackups { | | leaf srlg-strict-autobackups { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of autobackup tunnels that are | | "Total number of autobackup tunnels that are |
| using SRLG strict"; | | using SRLG strict"; |
| } | | } |
| leaf srlg-preferred-autobackups { | | leaf srlg-preferred-autobackups { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of autobackup tunnels that are | | "Total number of autobackup tunnels that are |
| using SRLG preferred"; | | using SRLG preferred"; |
| } | | } |
| leaf srlg-weighted-autobackups { | | leaf srlg-weighted-autobackups { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of autobackup tunnels that are | | "Total number of autobackup tunnels that are |
| using weighted SRLG"; | | using weighted SRLG"; |
| } | | } |
| leaf bandwidth-protection-autobackups { | | leaf bandwidth-protection-autobackups { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of autobackup tunnels with | | "Total number of autobackup tunnels with |
| bandwidth protection"; | | bandwidth protection"; |
| } | | } |
| leaf next-hop-autobackup-protected-ls-ps { | | leaf next-hop-autobackup-protected-ls-ps { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of autobackup protected LSPs with | | "Total number of autobackup protected LSPs with |
| NHOP and no SRLG"; | | NHOP and no SRLG"; |
| } | | } |
| leaf next-next-hop-autobackup-protected-ls-ps { | | leaf next-next-hop-autobackup-protected-ls-ps { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of autobackup protected LSPs with | | "Total number of autobackup protected LSPs with |
| NNHOP and no SRLG"; | | NNHOP and no SRLG"; |
| } | | } |
| leaf next-hop-srlg-autobackup-protected-ls-ps { | | leaf next-hop-srlg-autobackup-protected-ls-ps { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of autobackup protected LSPs with | | "Total number of autobackup protected LSPs with |
| NHOP and SRLG"; | | NHOP and SRLG"; |
| } | | } |
| leaf next-next-hop-srlg-autobackup-protected-ls-ps { | | leaf next-next-hop-srlg-autobackup-protected-ls-ps { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of autobackup protected LSPs with | | "Total number of autobackup protected LSPs with |
| NNHOP and SRLG"; | | NNHOP and SRLG"; |
| } | | } |
| leaf next-hop-bw-autobackup-protected-ls-ps { | | leaf next-hop-bw-autobackup-protected-ls-ps { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of autobackup protected LSPs with | | "Total number of autobackup protected LSPs with |
| NHOP and BW"; | | NHOP and BW"; |
| } | | } |
| leaf next-next-hop-bw-autobackup-protected-ls-ps { | | leaf next-next-hop-bw-autobackup-protected-ls-ps { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of autobackup protected LSPs with | | "Total number of autobackup protected LSPs with |
| NNHOP and BW"; | | NNHOP and BW"; |
| } | | } |
| leaf next-hop-bwsrlg-autobackup-protected-ls-ps { | | leaf next-hop-bwsrlg-autobackup-protected-ls-ps { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of autobackup protected LSPs with | | "Total number of autobackup protected LSPs with |
| NHOP, BW and SRLG"; | | NHOP, BW and SRLG"; |
| } | | } |
| leaf next-next-hop-bwsrlg-autobackup-protected-ls-ps { | | leaf next-next-hop-bwsrlg-autobackup-protected-ls-ps { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of autobackup protected LSPs with | | "Total number of autobackup protected LSPs with |
| NNHOP, BW and SRLG"; | | NNHOP, BW and SRLG"; |
| } | | } |
| leaf next-hop-autobackup-protected-s2l-families { | | leaf next-hop-autobackup-protected-s2l-families { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of autobackup protected S2L | | "Total number of autobackup protected S2L |
| Families with NHOP and no SRLG"; | | Families with NHOP and no SRLG"; |
| } | | } |
| leaf next-next-hop-autobackup-protected-s2l-families { | | leaf next-next-hop-autobackup-protected-s2l-families { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of autobackup protected S2L | | "Total number of autobackup protected S2L |
| Families with NNHOP and no SRLG"; | | Families with NNHOP and no SRLG"; |
| } | | } |
| leaf next-hop-srlg-autobackup-protected-s2l-families { | | leaf next-hop-srlg-autobackup-protected-s2l-families { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of autobackup protected S2L | | "Total number of autobackup protected S2L |
| Families with NHOP and SRLG"; | | Families with NHOP and SRLG"; |
| } | | } |
| leaf next-next-hop-srlg-autobackup-protected-s2l-families { | | leaf next-next-hop-srlg-autobackup-protected-s2l-families { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of autobackup protected S2L | | "Total number of autobackup protected S2L |
| Families with NNHOP and SRLG"; | | Families with NNHOP and SRLG"; |
| } | | } |
| leaf next-hop-bw-autobackup-protected-s2l-families { | | leaf next-hop-bw-autobackup-protected-s2l-families { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of autobackup protected S2L | | "Total number of autobackup protected S2L |
| Families with NHOP and BW and no SRLG"; | | Families with NHOP and BW and no SRLG"; |
| } | | } |
| leaf next-next-hop-bw-autobackup-protected-s2l-families { | | leaf next-next-hop-bw-autobackup-protected-s2l-families { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of autobackup protected S2L | | "Total number of autobackup protected S2L |
| Families with NNHOP and BW and no SRLG"; | | Families with NNHOP and BW and no SRLG"; |
| } | | } |
| leaf next-hop-bwsrlg-autobackup-protected-s2l-families { | | leaf next-hop-bwsrlg-autobackup-protected-s2l-families { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of autobackup protected S2L | | "Total number of autobackup protected S2L |
| Families with NHOP and BW and SRLG"; | | Families with NHOP and BW and SRLG"; |
| } | | } |
| leaf next-next-hop-bwsrlg-autobackup-protected-s2l-families { | | leaf next-next-hop-bwsrlg-autobackup-protected-s2l-families { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of autobackup protected S2L | | "Total number of autobackup protected S2L |
| Families with NNHOP and BW and SRLG"; | | Families with NNHOP and BW and SRLG"; |
| } | | } |
| leaf next-hop-autobackup-protected-s2-ls { | | leaf next-hop-autobackup-protected-s2-ls { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of autobackup protected S2Ls with | | "Total number of autobackup protected S2Ls with |
| NHOP and no SRLG"; | | NHOP and no SRLG"; |
| } | | } |
| leaf next-next-hop-autobackup-protected-s2-ls { | | leaf next-next-hop-autobackup-protected-s2-ls { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of autobackup protected S2Ls with | | "Total number of autobackup protected S2Ls with |
| NNHOP and no SRLG"; | | NNHOP and no SRLG"; |
| } | | } |
| leaf next-hop-srlg-autobackup-protected-s2-ls { | | leaf next-hop-srlg-autobackup-protected-s2-ls { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of autobackup protected S2Ls with | | "Total number of autobackup protected S2Ls with |
| NHOP and SRLG"; | | NHOP and SRLG"; |
| } | | } |
| leaf next-next-hop-srlg-autobackup-protected-s2-ls { | | leaf next-next-hop-srlg-autobackup-protected-s2-ls { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of autobackup protected S2Ls with | | "Total number of autobackup protected S2Ls with |
| NNHOP and SRLG"; | | NNHOP and SRLG"; |
| } | | } |
| leaf next-hop-bw-autobackup-protected-s2-ls { | | leaf next-hop-bw-autobackup-protected-s2-ls { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of autobackup protected S2Ls with | | "Total number of autobackup protected S2Ls with |
| NHOP and BW and no SRLG"; | | NHOP and BW and no SRLG"; |
| } | | } |
| leaf next-next-hop-bw-autobackup-protected-s2-ls { | | leaf next-next-hop-bw-autobackup-protected-s2-ls { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of autobackup protected S2Ls with | | "Total number of autobackup protected S2Ls with |
| NNHOP and BW and no SRLG"; | | NNHOP and BW and no SRLG"; |
| } | | } |
| leaf next-hop-bwsrlg-autobackup-protected-s2-ls { | | leaf next-hop-bwsrlg-autobackup-protected-s2-ls { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of autobackup protected S2Ls with | | "Total number of autobackup protected S2Ls with |
| NHOP and BW and SRLG"; | | NHOP and BW and SRLG"; |
| } | | } |
| leaf next-next-hop-bwsrlg-autobackup-protected-s2-ls { | | leaf next-next-hop-bwsrlg-autobackup-protected-s2-ls { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of autobackup protected S2Ls with | | "Total number of autobackup protected S2Ls with |
| NNHOP and BW and SRLG"; | | NNHOP and BW and SRLG"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-AUTOTUN-BACKUP-TUNNEL-INFO { | | grouping MPLS-TE-AUTOTUN-BACKUP-TUNNEL-INFO { |
| description | | description |
| "Auto-tunnel backup brief tunnel information"; | | "Auto-tunnel backup brief tunnel information"; |
| leaf tunnel-name { | | leaf tunnel-name { |
| type string; | | type string; |
| description | | description |
| "Tunnel Name"; | | "Tunnel Name"; |
| } | | } |
| leaf operational-status { | | leaf operational-status { |
| type Mpls-te-tunnel-state; | | type Mpls-te-tunnel-state; |
| description | | description |
| "Tunnel operational status"; | | "Tunnel operational status"; |
| } | | } |
| leaf srlg-mode { | | leaf srlg-mode { |
| type Auto-backup-srlg-mode; | | type Auto-backup-srlg-mode; |
| description | | description |
| "SRLG exclude mode for this auto-tunnel backup"; | | "SRLG exclude mode for this auto-tunnel backup"; |
| } | | } |
| leaf atb-protection-type { | | leaf atb-protection-type { |
| type Auto-backup-protection; | | type Auto-backup-protection; |
| description | | description |
| "Type of protection offered by this auto-tunnel | | "Type of protection offered by this auto-tunnel |
| backup"; | | backup"; |
| } | | } |
| leaf protected-flows { | | leaf protected-flows { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of protected flows"; | | "Number of protected flows"; |
| } | | } |
| leaf protected-interface-name { | | leaf protected-interface-name { |
| type string; | | type string; |
| description | | description |
| "Interface protected by this auto-tunnel backup"; | | "Interface protected by this auto-tunnel backup"; |
| } | | } |
| leaf protected-router-id { | | leaf protected-router-id { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Router ID of node protected by this auto-tunnel | | "Router ID of node protected by this auto-tunnel |
| backup"; | | backup"; |
| } | | } |
| leaf bandwidth-protection { | | leaf bandwidth-protection { |
| type boolean; | | type boolean; |
| description | | description |
| "Tunnel provides bandwidth protection"; | | "Tunnel provides bandwidth protection"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-AUTOTUN-MESH-ONEHOP-SUMMARY-INFO { | | grouping MPLS-TE-AUTOTUN-MESH-ONEHOP-SUMMARY-INFO { |
| description | | description |
| "Autotunnel mesh onehop summary information"; | | "Autotunnel mesh onehop summary information"; |
| leaf auto-mesh-one-hop-tunnels { | | leaf auto-mesh-one-hop-tunnels { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of automesh onehop tunnels"; | | "Total number of automesh onehop tunnels"; |
| } | | } |
| leaf up-auto-mesh-one-hop-tunnels { | | leaf up-auto-mesh-one-hop-tunnels { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of automesh onehop tunnels that are | | "Total number of automesh onehop tunnels that are |
| up"; | | up"; |
| } | | } |
| leaf down-auto-mesh-one-hop-tunnels { | | leaf down-auto-mesh-one-hop-tunnels { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of automesh onehop tunnels that are | | "Total number of automesh onehop tunnels that are |
| down"; | | down"; |
| } | | } |
| leaf frr-auto-mesh-tunnels { | | leaf frr-auto-mesh-tunnels { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of automesh onehop tunnels that are | | "Total number of automesh onehop tunnels that are |
| FRR enabled"; | | FRR enabled"; |
| } | | } |
| leaf auto-mesh-one-hop-groups { | | leaf auto-mesh-one-hop-groups { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of automesh onehop mesh-groups"; | | "Total number of automesh onehop mesh-groups"; |
| } | | } |
| leaf auto-mesh-one-hop-destinations { | | leaf auto-mesh-one-hop-destinations { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of automesh onehop destinations"; | | "Total number of automesh onehop destinations"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-AUTOMESH-ONEHOP-TUNNEL { | | grouping MPLS-TE-AUTOMESH-ONEHOP-TUNNEL { |
| description | | description |
| "TE Automesh Onehop Tunnel"; | | "TE Automesh Onehop Tunnel"; |
| leaf tunnel-id { | | leaf tunnel-id { |
| type uint16; | | type uint16; |
| description | | description |
| "Tunnel ID"; | | "Tunnel ID"; |
| } | | } |
| leaf destination-address { | | leaf destination-address { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Destination Address"; | | "Destination Address"; |
| } | | } |
| leaf tunnel-lspid { | | leaf tunnel-lspid { |
| type uint16; | | type uint16; |
| description | | description |
| "LSP ID"; | | "LSP ID"; |
| } | | } |
| leaf mesh-group-id { | | leaf mesh-group-id { |
| type uint32; | | type uint32; |
| description | | description |
| "Meshgroup ID"; | | "Meshgroup ID"; |
| } | | } |
| leaf tunnel-state { | | leaf tunnel-state { |
| type Mpls-te-tunnel-state; | | type Mpls-te-tunnel-state; |
| description | | description |
| "Tunnel state"; | | "Tunnel state"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-AUTOMESH-ONEHOP-INTERFACE { | | grouping MPLS-TE-AUTOMESH-ONEHOP-INTERFACE { |
| description | | description |
| "TE Automesh Onehop Interface"; | | "TE Automesh Onehop Interface"; |
| leaf interface-name-xr { | | leaf interface-name-xr { |
| type string; | | type string; |
| description | | description |
| "Interface name"; | | "Interface name"; |
| } | | } |
| list tunnel { | | list tunnel { |
| description | | description |
| "Onehop tunnels created for this interface"; | | "Onehop tunnels created for this interface"; |
| uses MPLS-TE-AUTOMESH-ONEHOP-TUNNEL; | | uses MPLS-TE-AUTOMESH-ONEHOP-TUNNEL; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-AUTOTUN-MESH-CONFIG-INFO { | | grouping MPLS-TE-AUTOTUN-MESH-CONFIG-INFO { |
| description | | description |
| "Auto-tunnel mesh feature configuration | | "Auto-tunnel mesh feature configuration |
| information"; | | information"; |
| leaf is-configured { | | leaf is-configured { |
| type boolean; | | type boolean; |
| description | | description |
| "Indicate if auto-tunnel mesh feature is | | "Indicate if auto-tunnel mesh feature is |
| configured "; | | configured "; |
| } | | } |
| leaf unused-removal-timeout-configured { | | leaf unused-removal-timeout-configured { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Configured value of unused removal timer in | | "Configured value of unused removal timer in |
| seconds"; | | seconds"; |
| } | | } |
| leaf min-tunnel-id { | | leaf min-tunnel-id { |
| type uint16; | | type uint16; |
| description | | description |
| "Lower bound of configured tunnel ID range"; | | "Lower bound of configured tunnel ID range"; |
| } | | } |
| leaf max-tunnel-id { | | leaf max-tunnel-id { |
| type uint16; | | type uint16; |
| description | | description |
| "Upper bound of configured tunnel ID range"; | | "Upper bound of configured tunnel ID range"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-AUTOTUN-MESH-SUMMARY-INFO { | | grouping MPLS-TE-AUTOTUN-MESH-SUMMARY-INFO { |
| description | | description |
| "Autotunnel mesh summary information"; | | "Autotunnel mesh summary information"; |
| leaf auto-mesh-tunnels { | | leaf auto-mesh-tunnels { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of automesh tunnels"; | | "Total number of automesh tunnels"; |
| } | | } |
| leaf up-auto-mesh-tunnels { | | leaf up-auto-mesh-tunnels { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of automesh tunnels that are up"; | | "Total number of automesh tunnels that are up"; |
| } | | } |
| leaf down-auto-mesh-tunnels { | | leaf down-auto-mesh-tunnels { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of automesh tunnels that are down"; | | "Total number of automesh tunnels that are down"; |
| } | | } |
| leaf frr-auto-mesh-tunnels { | | leaf frr-auto-mesh-tunnels { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of automesh tunnels that are FRR | | "Total number of automesh tunnels that are FRR |
| enabled"; | | enabled"; |
| } | | } |
| leaf auto-mesh-groups { | | leaf auto-mesh-groups { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of automesh mesh-groups"; | | "Total number of automesh mesh-groups"; |
| } | | } |
| leaf auto-mesh-destinations { | | leaf auto-mesh-destinations { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of automesh destinations"; | | "Total number of automesh destinations"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-MESHGROUP-DEST { | | grouping MPLS-TE-MESHGROUP-DEST { |
| description | | description |
| "TE Meshgroup destination info"; | | "TE Meshgroup destination info"; |
| leaf destination-address { | | leaf destination-address { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Destination address"; | | "Destination address"; |
| } | | } |
| leaf tunnel-id { | | leaf tunnel-id { |
| type uint16; | | type uint16; |
| description | | description |
| "Tunnel ID"; | | "Tunnel ID"; |
| } | | } |
| leaf operational-status { | | leaf operational-status { |
| type Mpls-te-tunnel-state; | | type Mpls-te-tunnel-state; |
| description | | description |
| "Tunnel operational status"; | | "Tunnel operational status"; |
| } | | } |
| leaf remaining-time { | | leaf remaining-time { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Remaining time for unused timer in seconds"; | | "Remaining time for unused timer in seconds"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-MESHGROUP { | | grouping MPLS-TE-MESHGROUP { |
| description | | description |
| "TE Meshgroup info"; | | "TE Meshgroup info"; |
| leaf mesh-group-id-xr { | | leaf mesh-group-id-xr { |
| type uint32; | | type uint32; |
| description | | description |
| "Meshgroup ID"; | | "Meshgroup ID"; |
| } | | } |
| leaf is-meshgroup-disabled { | | leaf is-meshgroup-disabled { |
| type boolean; | | type boolean; |
| description | | description |
| "Is the meshgroup disabled"; | | "Is the meshgroup disabled"; |
| } | | } |
| leaf attribute-set-name { | | leaf attribute-set-name { |
| type string; | | type string; |
| description | | description |
| "Attribute set name"; | | "Attribute set name"; |
| } | | } |
| leaf is-attribute-set-configured { | | leaf is-attribute-set-configured { |
| type boolean; | | type boolean; |
| description | | description |
| "Is any attribute-set associated to this | | "Is any attribute-set associated to this |
| meshgroup"; | | meshgroup"; |
| } | | } |
| leaf is-attribute-set-in-db { | | leaf is-attribute-set-in-db { |
| type boolean; | | type boolean; |
| description | | description |
| "Flag to indicate the existence of attribute set | | "Flag to indicate the existence of attribute set |
| found in database"; | | found in database"; |
| } | | } |
| leaf destination-list-name { | | leaf destination-list-name { |
| type string; | | type string; |
| description | | description |
| "Destination List name"; | | "Destination List name"; |
| } | | } |
| leaf is-destination-list-configured { | | leaf is-destination-list-configured { |
| type boolean; | | type boolean; |
| description | | description |
| "Is any destiantion-list associated to this | | "Is any destiantion-list associated to this |
| meshgroup"; | | meshgroup"; |
| } | | } |
| leaf destination-list-type { | | leaf destination-list-type { |
| type Te-acl; | | type Te-acl; |
| description | | description |
| "Type of the destlist"; | | "Type of the destlist"; |
| } | | } |
| leaf remaining-time { | | leaf remaining-time { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Remaining time for recreate timer in seconds"; | | "Remaining time for recreate timer in seconds"; |
| } | | } |
| leaf auto-mesh-tunnels { | | leaf auto-mesh-tunnels { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of automesh tunnels"; | | "Total number of automesh tunnels"; |
| } | | } |
| leaf auto-mesh-total-destinations { | | leaf auto-mesh-total-destinations { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of destinations"; | | "Total number of destinations"; |
| } | | } |
| leaf up-auto-mesh-tunnels { | | leaf up-auto-mesh-tunnels { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of automesh tunnels that are up"; | | "Total number of automesh tunnels that are up"; |
| } | | } |
| leaf down-auto-mesh-tunnels { | | leaf down-auto-mesh-tunnels { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of automesh tunnels that are down"; | | "Total number of automesh tunnels that are down"; |
| } | | } |
| leaf frr-auto-mesh-tunnels { | | leaf frr-auto-mesh-tunnels { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of automesh tunnels that are FRR | | "Total number of automesh tunnels that are FRR |
| enabled"; | | enabled"; |
| } | | } |
| leaf auto-mesh-group-type { | | leaf auto-mesh-group-type { |
| type Te-meshgroup; | | type Te-meshgroup; |
| description | | description |
| "Meshgroup Type"; | | "Meshgroup Type"; |
| } | | } |
| list destination { | | list destination { |
| description | | description |
| "List of destinations for this meshgroup"; | | "List of destinations for this meshgroup"; |
| uses MPLS-TE-MESHGROUP-DEST; | | uses MPLS-TE-MESHGROUP-DEST; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-AUTOTUN-PCC-SUMMARY-INFO { | | grouping MPLS-TE-AUTOTUN-PCC-SUMMARY-INFO { |
| description | | description |
| "Stateful PCE client auto-tunnel summary | | "Stateful PCE client auto-tunnel summary |
| information"; | | information"; |
| leaf pcc-auto-tunnel { | | leaf pcc-auto-tunnel { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of stateful PCE client auto-tunnels"; | | "Total number of stateful PCE client auto-tunnels"; |
| } | | } |
| leaf up-pcc-auto-tunnels { | | leaf up-pcc-auto-tunnels { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of stateful PCE client auto-tunnels | | "Total number of stateful PCE client auto-tunnels |
| that are up"; | | that are up"; |
| } | | } |
| leaf down-pcc-auto-tunnels { | | leaf down-pcc-auto-tunnels { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of stateful PCE client auto-tunnels | | "Total number of stateful PCE client auto-tunnels |
| that are down"; | | that are down"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-P2MP-TIMER-B { | | grouping MPLS-TE-P2MP-TIMER-B { |
| description | | description |
| "Description of a P2MP timer"; | | "Description of a P2MP timer"; |
| leaf timer-type { | | leaf timer-type { |
| type Mpls-te-p2mp-timer; | | type Mpls-te-p2mp-timer; |
| description | | description |
| "Timer Type"; | | "Timer Type"; |
| } | | } |
| leaf timer-name { | | leaf timer-name { |
| type string; | | type string; |
| description | | description |
| "Timer Name"; | | "Timer Name"; |
| } | | } |
| leaf start-time { | | leaf start-time { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Date when timer was last started in seconds"; | | "Date when timer was last started in seconds"; |
| } | | } |
| leaf expiry-time { | | leaf expiry-time { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Date when the timer last expired in seconds"; | | "Date when the timer last expired in seconds"; |
| } | | } |
| leaf stop-time { | | leaf stop-time { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Date when the timer was last stopped in seconds"; | | "Date when the timer was last stopped in seconds"; |
| } | | } |
| leaf duration { | | leaf duration { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "The expiry delay in seconds"; | | "The expiry delay in seconds"; |
| } | | } |
| leaf is-running { | | leaf is-running { |
| type boolean; | | type boolean; |
| description | | description |
| "True if the timer is running"; | | "True if the timer is running"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-P2MP-TIMERS-B { | | grouping MPLS-TE-P2MP-TIMERS-B { |
| description | | description |
| "Description of P2MP timers"; | | "Description of P2MP timers"; |
| list p2mp-timer { | | list p2mp-timer { |
| max-elements "30"; | | max-elements "30"; |
| description | | description |
| "Description of all P2MP timers"; | | "Description of all P2MP timers"; |
| uses MPLS-TE-P2MP-TIMER-B; | | uses MPLS-TE-P2MP-TIMER-B; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-AREA-AFI-INFO { | | grouping MPLS-TE-AREA-AFI-INFO { |
| description | | description |
| "IGP area information including AFI"; | | "IGP area information including AFI"; |
| leaf igp-area-id { | | leaf igp-area-id { |
| type string; | | type string; |
| description | | description |
| "The IGP Instance and Area ID"; | | "The IGP Instance and Area ID"; |
| } | | } |
| leaf afi { | | leaf afi { |
| type Mpls-te-afi; | | type Mpls-te-afi; |
| description | | description |
| "AFI"; | | "AFI"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-AUTOROUTE-BAG { | | grouping MPLS-TE-AUTOROUTE-BAG { |
| description | | description |
| "MPLS TE Autoroute Information"; | | "MPLS TE Autoroute Information"; |
| leaf tunnel-name { | | leaf tunnel-name { |
| type string; | | type string; |
| description | | description |
| "The tunnel name"; | | "The tunnel name"; |
| } | | } |
| leaf tunnel-sig-name { | | leaf tunnel-sig-name { |
| type string; | | type string; |
| description | | description |
| "The tunnel signaled-name"; | | "The tunnel signaled-name"; |
| } | | } |
| leaf tunnel-loadshare { | | leaf tunnel-loadshare { |
| type uint32; | | type uint32; |
| description | | description |
| "Tunnel loadshare"; | | "Tunnel loadshare"; |
| } | | } |
| leaf announce-type { | | leaf announce-type { |
| type Mpls-te-tunnel-announce; | | type Mpls-te-tunnel-announce; |
| description | | description |
| "Announcement type"; | | "Announcement type"; |
| } | | } |
| leaf next-hop-address { | | leaf next-hop-address { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "The tunnel destination"; | | "The tunnel destination"; |
| } | | } |
| leaf mode { | | leaf mode { |
| type Igpte-aa-metric-mode; | | type Igpte-aa-metric-mode; |
| description | | description |
| "Autoroute mode"; | | "Autoroute mode"; |
| } | | } |
| leaf igp-metric { | | leaf igp-metric { |
| type int32; | | type int32; |
| description | | description |
| "IGP metric"; | | "IGP metric"; |
| } | | } |
| leaf hold-time { | | leaf hold-time { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Hold time in seconds"; | | "Hold time in seconds"; |
| } | | } |
| leaf area-format { | | leaf area-format { |
| type Igp-ospf-area-format; | | type Igp-ospf-area-format; |
| description | | description |
| "IGP Area Format"; | | "IGP Area Format"; |
| } | | } |
| leaf is-auto-mesh-aa { | | leaf is-auto-mesh-aa { |
| type boolean; | | type boolean; |
| description | | description |
| "True if this is auto-tunnel mesh AA"; | | "True if this is auto-tunnel mesh AA"; |
| } | | } |
| leaf is-sr { | | leaf is-sr { |
| type boolean; | | type boolean; |
| description | | description |
| "True if this is a segment routing tunnel"; | | "True if this is a segment routing tunnel"; |
| } | | } |
| leaf is-sr-strict { | | leaf is-sr-strict { |
| type boolean; | | type boolean; |
| description | | description |
| "True if this is a strict SID SR tunnel"; | | "True if this is a strict SID SR tunnel"; |
| } | | } |
| leaf mesh-group-idaa { | | leaf mesh-group-idaa { |
| type uint32; | | type uint32; |
| description | | description |
| "MeshGroup ID for AA"; | | "MeshGroup ID for AA"; |
| } | | } |
| leaf is-exclude-segment-routing { | | leaf is-exclude-segment-routing { |
| type boolean; | | type boolean; |
| description | | description |
| "True if autoroute-announce has exclude | | "True if autoroute-announce has exclude |
| segment-routing option"; | | segment-routing option"; |
| n | } | n | |
| leaf is-exclude-segment-routing-all { | | |
| type boolean; | | |
| description | | |
| "True if autoroute-announce has exclude | | |
| segment-routing-all option"; | | |
| } | | } |
| list ig-ps { | | list ig-ps { |
| description | | description |
| "List of IGPs to which it is announced"; | | "List of IGPs to which it is announced"; |
| uses MPLS-TE-AREA-AFI-INFO; | | uses MPLS-TE-AREA-AFI-INFO; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-ANNOUNCEMENT-DEST-BAG { | | grouping MPLS-TE-ANNOUNCEMENT-DEST-BAG { |
| description | | description |
| "The summary info of announcements for a | | "The summary info of announcements for a |
| destination and an IGP area"; | | destination and an IGP area"; |
| leaf igp-type { | | leaf igp-type { |
| type Igp-protocol; | | type Igp-protocol; |
| description | | description |
| "IGP type"; | | "IGP type"; |
| } | | } |
| leaf igp-instance { | | leaf igp-instance { |
| type string; | | type string; |
| description | | description |
| "IGP Instance name"; | | "IGP Instance name"; |
| } | | } |
| leaf igp-area { | | leaf igp-area { |
| type uint32; | | type uint32; |
| description | | description |
| "IGP Area ID"; | | "IGP Area ID"; |
| } | | } |
| leaf destination { | | leaf destination { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Destination"; | | "Destination"; |
| } | | } |
| leaf announced-tunnels-count { | | leaf announced-tunnels-count { |
| type uint16; | | type uint16; |
| description | | description |
| "The number of announced tunnels"; | | "The number of announced tunnels"; |
| } | | } |
| leaf autorouted-tunnels-count { | | leaf autorouted-tunnels-count { |
| type uint16; | | type uint16; |
| description | | description |
| "The number of tunnels that are announced as | | "The number of tunnels that are announced as |
| shortcuts"; | | shortcuts"; |
| } | | } |
| leaf forwarding-adjacency-tunnels-count { | | leaf forwarding-adjacency-tunnels-count { |
| type uint16; | | type uint16; |
| description | | description |
| "The number of tunnels that are announced as | | "The number of tunnels that are announced as |
| forwarding adjacencies"; | | forwarding adjacencies"; |
| } | | } |
| leaf area-format { | | leaf area-format { |
| type Igp-ospf-area-format; | | type Igp-ospf-area-format; |
| description | | description |
| "The format for the area: IPv4 address or a | | "The format for the area: IPv4 address or a |
| positive integer"; | | positive integer"; |
| } | | } |
| list total-tunnel { | | list total-tunnel { |
| description | | description |
| "Announced tunnels for this destination"; | | "Announced tunnels for this destination"; |
| uses MPLS-TE-AUTOROUTE-BAG; | | uses MPLS-TE-AUTOROUTE-BAG; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-TOPOLOGY-LINK-LOSS { | | grouping MPLS-TE-TOPOLOGY-LINK-LOSS { |
| description | | description |
| "MPLS TE Link Loss Attribute"; | | "MPLS TE Link Loss Attribute"; |
| leaf anomalous-bit { | | leaf anomalous-bit { |
| type boolean; | | type boolean; |
| description | | description |
| "Anomalous (A) Bit"; | | "Anomalous (A) Bit"; |
| } | | } |
| leaf loss-value { | | leaf loss-value { |
| type uint32; | | type uint32; |
| description | | description |
| "Loss Value"; | | "Loss Value"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-TOPOLOGY-LINK-MIN-MAX-DELAY { | | grouping MPLS-TE-TOPOLOGY-LINK-MIN-MAX-DELAY { |
| description | | description |
| "MPLS TE Link Loss Attribute"; | | "MPLS TE Link Loss Attribute"; |
| leaf anomalous-bit { | | leaf anomalous-bit { |
| type boolean; | | type boolean; |
| description | | description |
| "Anomalous (A) Bit"; | | "Anomalous (A) Bit"; |
| } | | } |
| leaf minimum-delay { | | leaf minimum-delay { |
| type uint32; | | type uint32; |
| description | | description |
| "Mimimum measured link delay value in usec"; | | "Mimimum measured link delay value in usec"; |
| } | | } |
| leaf maximum-delay { | | leaf maximum-delay { |
| type uint32; | | type uint32; |
| description | | description |
| "Maximum measured link delay value in usec"; | | "Maximum measured link delay value in usec"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-TOPOLOGY-LINK-BW-STD-DETAIL { | | grouping MPLS-TE-TOPOLOGY-LINK-BW-STD-DETAIL { |
| description | | description |
| "Detailed DSTE bandwidth information for a link"; | | "Detailed DSTE bandwidth information for a link"; |
| list topo-link-std-bw-allocated { | | list topo-link-std-bw-allocated { |
| max-elements "8"; | | max-elements "8"; |
| description | | description |
| "Link's allocated bandwidth per class"; | | "Link's allocated bandwidth per class"; |
| leaf entry { | | leaf entry { |
| type uint32; | | type uint32; |
| description | | description |
| "Link's allocated bandwidth per class"; | | "Link's allocated bandwidth per class"; |
| } | | } |
| } | | } |
| list topo-link-std-bw-available { | | list topo-link-std-bw-available { |
| max-elements "8"; | | max-elements "8"; |
| description | | description |
| "Link's available bandwidth per class"; | | "Link's available bandwidth per class"; |
| leaf entry { | | leaf entry { |
| type uint32; | | type uint32; |
| description | | description |
| "Link's available bandwidth per class"; | | "Link's available bandwidth per class"; |
| } | | } |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-TOPOLOGY-LINK-BW-STD { | | grouping MPLS-TE-TOPOLOGY-LINK-BW-STD { |
| description | | description |
| "IETF_standard bandwidth information for a link | | "IETF_standard bandwidth information for a link |
| belonging to a node in the MPLS TE topology"; | | belonging to a node in the MPLS TE topology"; |
| container topo-link-std-bw-detail { | | container topo-link-std-bw-detail { |
| description | | description |
| "Detailed bandwidth information for this link"; | | "Detailed bandwidth information for this link"; |
| uses MPLS-TE-TOPOLOGY-LINK-BW-STD-DETAIL; | | uses MPLS-TE-TOPOLOGY-LINK-BW-STD-DETAIL; |
| } | | } |
| leaf topo-link-std-bw-physical { | | leaf topo-link-std-bw-physical { |
| type uint32; | | type uint32; |
| description | | description |
| "The link's physical bandwidth"; | | "The link's physical bandwidth"; |
| } | | } |
| leaf topo-link-std-bw-res-max { | | leaf topo-link-std-bw-res-max { |
| type uint32; | | type uint32; |
| description | | description |
| "The link's maximum reservable bandwidth"; | | "The link's maximum reservable bandwidth"; |
| } | | } |
| leaf topo-link-std-bw-res-pool0 { | | leaf topo-link-std-bw-res-pool0 { |
| type uint32; | | type uint32; |
| description | | description |
| "The link's reservable BC0 bandwidth"; | | "The link's reservable BC0 bandwidth"; |
| } | | } |
| leaf topo-link-std-bw-res-pool1 { | | leaf topo-link-std-bw-res-pool1 { |
| type uint32; | | type uint32; |
| description | | description |
| "The link's reservable BC1 bandwidth"; | | "The link's reservable BC1 bandwidth"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-TOPOLOGY-LINK-BW-PRESTD-DETAIL { | | grouping MPLS-TE-TOPOLOGY-LINK-BW-PRESTD-DETAIL { |
| description | | description |
| "Detailed pre-standard bandwidth information for a | | "Detailed pre-standard bandwidth information for a |
| link"; | | link"; |
| list topology-link-prestandard-bandwidth-allocated { | | list topology-link-prestandard-bandwidth-allocated { |
| max-elements "8"; | | max-elements "8"; |
| description | | description |
| "Link's allocated bandwidth at priority levels | | "Link's allocated bandwidth at priority levels |
| | | |
| (priority 0 to priority 7)"; | | (priority 0 to priority 7)"; |
| leaf entry { | | leaf entry { |
| type uint32; | | type uint32; |
| description | | description |
| "Link's allocated bandwidth at priority levels | | "Link's allocated bandwidth at priority levels |
| | | |
| (priority 0 to priority 7)"; | | (priority 0 to priority 7)"; |
| } | | } |
| } | | } |
| list topology-link-prestandard-bandwidth-available-global { | | list topology-link-prestandard-bandwidth-available-global { |
| max-elements "8"; | | max-elements "8"; |
| description | | description |
| "Link's available global-pool bandwidth at | | "Link's available global-pool bandwidth at |
| | | |
| priority levels (priority 0 to priority 7)"; | | priority levels (priority 0 to priority 7)"; |
| leaf entry { | | leaf entry { |
| type uint32; | | type uint32; |
| description | | description |
| "Link's available global-pool bandwidth at | | "Link's available global-pool bandwidth at |
| | | |
| priority levels (priority 0 to priority 7)"; | | priority levels (priority 0 to priority 7)"; |
| } | | } |
| } | | } |
| list topology-link-prestandard-bandwidth-available-subpool { | | list topology-link-prestandard-bandwidth-available-subpool { |
| max-elements "8"; | | max-elements "8"; |
| description | | description |
| "Link's available sub-pool bandwidth at priority | | "Link's available sub-pool bandwidth at priority |
| | | |
| levels (priority 0 to priority 7)"; | | levels (priority 0 to priority 7)"; |
| leaf entry { | | leaf entry { |
| type uint32; | | type uint32; |
| description | | description |
| "Link's available sub-pool bandwidth at priority | | "Link's available sub-pool bandwidth at priority |
| | | |
| levels (priority 0 to priority 7)"; | | levels (priority 0 to priority 7)"; |
| } | | } |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-TOPOLOGY-LINK-BW-PRESTD { | | grouping MPLS-TE-TOPOLOGY-LINK-BW-PRESTD { |
| description | | description |
| "Pre-standard bandwidth information for a link | | "Pre-standard bandwidth information for a link |
| belonging to a node in the MPLS TE topology"; | | belonging to a node in the MPLS TE topology"; |
| container topology-link-prestandard-bandwidth-detail { | | container topology-link-prestandard-bandwidth-detail { |
| description | | description |
| "Detailed bandwidth information for this link"; | | "Detailed bandwidth information for this link"; |
| uses MPLS-TE-TOPOLOGY-LINK-BW-PRESTD-DETAIL; | | uses MPLS-TE-TOPOLOGY-LINK-BW-PRESTD-DETAIL; |
| } | | } |
| leaf topology-link-prestandard-bandwidth-physical { | | leaf topology-link-prestandard-bandwidth-physical { |
| type uint32; | | type uint32; |
| description | | description |
| "The link's physical bandwidth"; | | "The link's physical bandwidth"; |
| } | | } |
| leaf topology-link-prestandard-bandwidth-reservation-global { | | leaf topology-link-prestandard-bandwidth-reservation-global { |
| type uint32; | | type uint32; |
| description | | description |
| "The link's reservable global bandwidth"; | | "The link's reservable global bandwidth"; |
| } | | } |
| leaf topology-link-prestandard-bandwidth-reservation-subpool { | | leaf topology-link-prestandard-bandwidth-reservation-subpool { |
| type uint32; | | type uint32; |
| description | | description |
| "The link's reservable subpool bandwidth"; | | "The link's reservable subpool bandwidth"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-TOPOLOGY-LINK-BW { | | grouping MPLS-TE-TOPOLOGY-LINK-BW { |
| description | | description |
| "Bandwidth information for a link"; | | "Bandwidth information for a link"; |
| container topology-link-bandwidth-prestandard { | | container topology-link-bandwidth-prestandard { |
| when "../bandwidth-migration-mode = 'rrr-dste-mode-prestandard'" { | | when "../bandwidth-migration-mode = 'rrr-dste-mode-prestandard'" { |
| description | | description |
| "../BandwidthMigrationMode = | | "../BandwidthMigrationMode = |
| 'RRR_DSTEModePrestandard'"; | | 'RRR_DSTEModePrestandard'"; |
| } | | } |
| description | | description |
| "Pre-standard bandwidth information for this link"; | | "Pre-standard bandwidth information for this link"; |
| uses MPLS-TE-TOPOLOGY-LINK-BW-PRESTD; | | uses MPLS-TE-TOPOLOGY-LINK-BW-PRESTD; |
| } | | } |
| container topology-link-bandwidth-standard { | | container topology-link-bandwidth-standard { |
| when "../bandwidth-migration-mode = 'rrr-dste-mode-standard'" { | | when "../bandwidth-migration-mode = 'rrr-dste-mode-standard'" { |
| description | | description |
| "../BandwidthMigrationMode = | | "../BandwidthMigrationMode = |
| 'RRR_DSTEModeStandard'"; | | 'RRR_DSTEModeStandard'"; |
| } | | } |
| description | | description |
| "IETF-standard bandwidth information for this | | "IETF-standard bandwidth information for this |
| link"; | | link"; |
| uses MPLS-TE-TOPOLOGY-LINK-BW-STD; | | uses MPLS-TE-TOPOLOGY-LINK-BW-STD; |
| } | | } |
| leaf bandwidth-migration-mode { | | leaf bandwidth-migration-mode { |
| type Rrr-dste-migration-mode; | | type Rrr-dste-migration-mode; |
| description | | description |
| "BandwidthMigrationMode"; | | "BandwidthMigrationMode"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-TOPOLOGY-LINK { | | grouping MPLS-TE-TOPOLOGY-LINK { |
| description | | description |
| "A link belonging to a node in the MPLS TE | | "A link belonging to a node in the MPLS TE |
| topology"; | | topology"; |
| container topology-link-bandwidth { | | container topology-link-bandwidth { |
| description | | description |
| "Bandwidth information for this link"; | | "Bandwidth information for this link"; |
| uses MPLS-TE-TOPOLOGY-LINK-BW; | | uses MPLS-TE-TOPOLOGY-LINK-BW; |
| } | | } |
| container odu-link-capabilities { | | container odu-link-capabilities { |
| description | | description |
| "ODU Link Capabilities"; | | "ODU Link Capabilities"; |
| uses ODU-LINK-CAPABILITIES; | | uses ODU-LINK-CAPABILITIES; |
| } | | } |
| container min-max-delay { | | container min-max-delay { |
| description | | description |
| "Minimum and maximum measured link delay"; | | "Minimum and maximum measured link delay"; |
| uses MPLS-TE-TOPOLOGY-LINK-MIN-MAX-DELAY; | | uses MPLS-TE-TOPOLOGY-LINK-MIN-MAX-DELAY; |
| } | | } |
| container loss { | | container loss { |
| description | | description |
| "Link Loss"; | | "Link Loss"; |
| uses MPLS-TE-TOPOLOGY-LINK-LOSS; | | uses MPLS-TE-TOPOLOGY-LINK-LOSS; |
| } | | } |
| leaf topology-link-type { | | leaf topology-link-type { |
| type Igp-subnet; | | type Igp-subnet; |
| description | | description |
| "Link type"; | | "Link type"; |
| } | | } |
| leaf topology-link-interface-address { | | leaf topology-link-interface-address { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Link's local interface address"; | | "Link's local interface address"; |
| } | | } |
| leaf topology-link-interface-id { | | leaf topology-link-interface-id { |
| type uint32; | | type uint32; |
| description | | description |
| "Link's local interface ID"; | | "Link's local interface ID"; |
| } | | } |
| leaf topology-link-neighbor-address { | | leaf topology-link-neighbor-address { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Link's neighbor interface address"; | | "Link's neighbor interface address"; |
| } | | } |
| leaf topology-link-neighbor-id { | | leaf topology-link-neighbor-id { |
| type uint32; | | type uint32; |
| description | | description |
| "Link's neighbor interface ID"; | | "Link's neighbor interface ID"; |
| } | | } |
| leaf topology-link-neighbor-system-id { | | leaf topology-link-neighbor-system-id { |
| type string; | | type string; |
| description | | description |
| "System id of neighbor"; | | "System id of neighbor"; |
| } | | } |
| leaf topology-link-neighbor-node-id { | | leaf topology-link-neighbor-node-id { |
| type uint32; | | type uint32; |
| description | | description |
| "Node id of neighbor"; | | "Node id of neighbor"; |
| } | | } |
| leaf topology-link-neighbor-generation { | | leaf topology-link-neighbor-generation { |
| type uint32; | | type uint32; |
| description | | description |
| "Neighbor's link version counter"; | | "Neighbor's link version counter"; |
| } | | } |
| leaf topology-link-fragment-id { | | leaf topology-link-fragment-id { |
| type uint32; | | type uint32; |
| description | | description |
| "Neighbor's link version counter"; | | "Neighbor's link version counter"; |
| } | | } |
| leaf topology-link-te-metric { | | leaf topology-link-te-metric { |
| type uint32; | | type uint32; |
| description | | description |
| "The link's TE metric"; | | "The link's TE metric"; |
| } | | } |
| leaf topology-link-igp-metric { | | leaf topology-link-igp-metric { |
| type uint32; | | type uint32; |
| description | | description |
| "The link's IGP metric"; | | "The link's IGP metric"; |
| } | | } |
| leaf topology-link-uni-delay { | | leaf topology-link-uni-delay { |
| type uint32; | | type uint32; |
| description | | description |
| "Unidirectional Link Delay in micro-sec"; | | "Unidirectional Link Delay in micro-sec"; |
| } | | } |
| leaf topology-link-affinity-bits { | | leaf topology-link-affinity-bits { |
| type uint32; | | type uint32; |
| description | | description |
| "Deprecated"; | | "Deprecated"; |
| } | | } |
| leaf topology-link-switching-capability { | | leaf topology-link-switching-capability { |
| type uint8; | | type uint8; |
| description | | description |
| "The link's switching capability"; | | "The link's switching capability"; |
| } | | } |
| leaf topology-link-encoding { | | leaf topology-link-encoding { |
| type uint8; | | type uint8; |
| description | | description |
| "The link's encoding"; | | "The link's encoding"; |
| } | | } |
| leaf topology-link-bandwidth-model { | | leaf topology-link-bandwidth-model { |
| type Igpte-lib-bw-model; | | type Igpte-lib-bw-model; |
| description | | description |
| "The link's topology bandwidth model"; | | "The link's topology bandwidth model"; |
| } | | } |
| leaf delay-variation { | | leaf delay-variation { |
| type uint32; | | type uint32; |
| description | | description |
| "Delay Variation"; | | "Delay Variation"; |
| } | | } |
| leaf residual-bandwidth { | | leaf residual-bandwidth { |
| type uint32; | | type uint32; |
| description | | description |
| "Residual Bandwidth (kbytes per seconds)"; | | "Residual Bandwidth (kbytes per seconds)"; |
| } | | } |
| leaf available-bandwidth { | | leaf available-bandwidth { |
| type uint32; | | type uint32; |
| units "byte/s"; | | units "byte/s"; |
| description | | description |
| "Available Bandwidth (kbytes per second)"; | | "Available Bandwidth (kbytes per second)"; |
| } | | } |
| leaf utilized-bandwidth { | | leaf utilized-bandwidth { |
| type uint32; | | type uint32; |
| units "byte/s"; | | units "byte/s"; |
| description | | description |
| "Utilized Bandwidth (kbytes per second)"; | | "Utilized Bandwidth (kbytes per second)"; |
| } | | } |
| list topology-link-extended-affinity-bit { | | list topology-link-extended-affinity-bit { |
| description | | description |
| "The link's affinity bits (colors)"; | | "The link's affinity bits (colors)"; |
| leaf entry { | | leaf entry { |
| type uint32; | | type uint32; |
| description | | description |
| "The link's affinity bits (colors)"; | | "The link's affinity bits (colors)"; |
| } | | } |
| } | | } |
| list shared-risk-link-group { | | list shared-risk-link-group { |
| description | | description |
| "The link's shared risk link groups"; | | "The link's shared risk link groups"; |
| uses MPLS-SRLG-INFO; | | uses MPLS-SRLG-INFO; |
| } | | } |
| list adjacency-sid { | | list adjacency-sid { |
| description | | description |
| "Adjacency SIDs assigned for adjacency nodes"; | | "Adjacency SIDs assigned for adjacency nodes"; |
| uses TE-SR-ADJ-SID; | | uses TE-SR-ADJ-SID; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-TOPOLOGY-NODE { | | grouping MPLS-TE-TOPOLOGY-NODE { |
| description | | description |
| "A node in the MPLS TE topology"; | | "A node in the MPLS TE topology"; |
| container topology-node-sid-and-srbg { | | container topology-node-sid-and-srbg { |
| description | | description |
| "This node's SID and SRBG information"; | | "This node's SID and SRBG information"; |
| uses TE-SR-NODE-INFO; | | uses TE-SR-NODE-INFO; |
| } | | } |
| leaf topology-node-te-router-id { | | leaf topology-node-te-router-id { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "The node's TE router-id. Not set for network | | "The node's TE router-id. Not set for network |
| nodes"; | | nodes"; |
| } | | } |
| leaf topology-node-overloaded { | | leaf topology-node-overloaded { |
| type boolean; | | type boolean; |
| description | | description |
| "Flag to indicate whether this node is overloaded"; | | "Flag to indicate whether this node is overloaded"; |
| } | | } |
| list topology-node-te-secondary-router-id { | | list topology-node-te-secondary-router-id { |
| description | | description |
| "The node's TE secondary router-ids array"; | | "The node's TE secondary router-ids array"; |
| leaf entry { | | leaf entry { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "The node's TE secondary router-ids array"; | | "The node's TE secondary router-ids array"; |
| } | | } |
| } | | } |
| list topology-node-link { | | list topology-node-link { |
| description | | description |
| "This node's link information"; | | "This node's link information"; |
| uses MPLS-TE-TOPOLOGY-LINK; | | uses MPLS-TE-TOPOLOGY-LINK; |
| } | | } |
| } | | } |
| | | |
| grouping TE-FIB-NH-PATH-BAG { | | grouping TE-FIB-NH-PATH-BAG { |
| description | | description |
| "TE FIB NH PATH BAG"; | | "TE FIB NH PATH BAG"; |
| leaf interface { | | leaf interface { |
| type xr:Interface-name; | | type xr:Interface-name; |
| description | | description |
| "Outgoing Interface"; | | "Outgoing Interface"; |
| } | | } |
| leaf next-hop-address { | | leaf next-hop-address { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Next Hop Address"; | | "Next Hop Address"; |
| } | | } |
| leaf path-id { | | leaf path-id { |
| type uint32; | | type uint32; |
| description | | description |
| "Path ID"; | | "Path ID"; |
| } | | } |
| leaf backup-path-id { | | leaf backup-path-id { |
| type uint32; | | type uint32; |
| description | | description |
| "Backup Path Identifier"; | | "Backup Path Identifier"; |
| } | | } |
| leaf pure-backup { | | leaf pure-backup { |
| type boolean; | | type boolean; |
| description | | description |
| "Pure Backup"; | | "Pure Backup"; |
| } | | } |
| list label-stack { | | list label-stack { |
| description | | description |
| "Outgoing Label Stack"; | | "Outgoing Label Stack"; |
| leaf entry { | | leaf entry { |
| type uint32; | | type uint32; |
| description | | description |
| "Outgoing Label Stack"; | | "Outgoing Label Stack"; |
| } | | } |
| } | | } |
| } | | } |
| | | |
| grouping TE-TARGET-ADDR { | | grouping TE-TARGET-ADDR { |
| description | | description |
| "TE Target Address Union"; | | "TE Target Address Union"; |
| leaf type { | | leaf type { |
| type Te-target-addr; | | type Te-target-addr; |
| description | | description |
| "type"; | | "type"; |
| } | | } |
| leaf ip-address { | | leaf ip-address { |
| when "../type = 'te-target-type-ipv4'" { | | when "../type = 'te-target-type-ipv4'" { |
| description | | description |
| "../type = 'TETargetTypeIPv4'"; | | "../type = 'TETargetTypeIPv4'"; |
| } | | } |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "IPv4 Address"; | | "IPv4 Address"; |
| } | | } |
| leaf label { | | leaf label { |
| when "../type = 'te-target-type-label'" { | | when "../type = 'te-target-type-label'" { |
| description | | description |
| "../type = 'TETargetTypeLabel'"; | | "../type = 'TETargetTypeLabel'"; |
| } | | } |
| type uint32; | | type uint32; |
| description | | description |
| "MPLS Label"; | | "MPLS Label"; |
| } | | } |
| } | | } |
| | | |
| grouping TE-FIB-NH-ROUTE-BAG { | | grouping TE-FIB-NH-ROUTE-BAG { |
| description | | description |
| "TE FIB NH ROUTE BAG"; | | "TE FIB NH ROUTE BAG"; |
| container target-address { | | container target-address { |
| description | | description |
| "Next Hop Target Address"; | | "Next Hop Target Address"; |
| uses TE-TARGET-ADDR; | | uses TE-TARGET-ADDR; |
| } | | } |
| leaf prefix-addr { | | leaf prefix-addr { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Deprecated - replaced by TargetAddress"; | | "Deprecated - replaced by TargetAddress"; |
| } | | } |
| leaf create-time { | | leaf create-time { |
| type uint32; | | type uint32; |
| description | | description |
| "Create Time"; | | "Create Time"; |
| } | | } |
| leaf last-used-time { | | leaf last-used-time { |
| type uint32; | | type uint32; |
| description | | description |
| "Last Used Time"; | | "Last Used Time"; |
| } | | } |
| leaf last-update-time { | | leaf last-update-time { |
| type uint32; | | type uint32; |
| description | | description |
| "Last Update Time"; | | "Last Update Time"; |
| } | | } |
| leaf expire-time { | | leaf expire-time { |
| type uint32; | | type uint32; |
| description | | description |
| "Expire Time"; | | "Expire Time"; |
| } | | } |
| leaf is-registered { | | leaf is-registered { |
| type boolean; | | type boolean; |
| description | | description |
| "Is Registered"; | | "Is Registered"; |
| } | | } |
| leaf is-notified { | | leaf is-notified { |
| type boolean; | | type boolean; |
| description | | description |
| "Is Notified"; | | "Is Notified"; |
| } | | } |
| leaf is-stale { | | leaf is-stale { |
| type boolean; | | type boolean; |
| description | | description |
| "Is Stale"; | | "Is Stale"; |
| } | | } |
| leaf route-version { | | leaf route-version { |
| type uint64; | | type uint64; |
| description | | description |
| "Route version"; | | "Route version"; |
| } | | } |
| list next-hop-path { | | list next-hop-path { |
| description | | description |
| "Next Hop Paths"; | | "Next Hop Paths"; |
| uses TE-FIB-NH-PATH-BAG; | | uses TE-FIB-NH-PATH-BAG; |
| } | | } |
| } | | } |
| | | |
| grouping NODE-ID { | | grouping NODE-ID { |
| description | | description |
| "NODE ID"; | | "NODE ID"; |
| leaf node-id { | | leaf node-id { |
| type string; | | type string; |
| description | | description |
| "Node Identifier"; | | "Node Identifier"; |
| } | | } |
| } | | } |
| | | |
| grouping TE-SR-BACKUP-PATH { | | grouping TE-SR-BACKUP-PATH { |
| description | | description |
| "Segment-Routing backup path"; | | "Segment-Routing backup path"; |
| leaf outgoing-interface { | | leaf outgoing-interface { |
| type string; | | type string; |
| description | | description |
| "Outgoing Interface Name"; | | "Outgoing Interface Name"; |
| } | | } |
| leaf next-hop { | | leaf next-hop { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Next hop"; | | "Next hop"; |
| } | | } |
| list outgoing-labels-stack { | | list outgoing-labels-stack { |
| description | | description |
| "Outgoing Labels Stack"; | | "Outgoing Labels Stack"; |
| leaf entry { | | leaf entry { |
| type uint32; | | type uint32; |
| description | | description |
| "Outgoing Labels Stack"; | | "Outgoing Labels Stack"; |
| } | | } |
| } | | } |
| list outgoing-strict-labels-stack { | | list outgoing-strict-labels-stack { |
| description | | description |
| "Outgoing Labels Stack for Strict SPF"; | | "Outgoing Labels Stack for Strict SPF"; |
| leaf entry { | | leaf entry { |
| type uint32; | | type uint32; |
| description | | description |
| "Outgoing Labels Stack for Strict SPF"; | | "Outgoing Labels Stack for Strict SPF"; |
| } | | } |
| } | | } |
| } | | } |
| | | |
| grouping TE-SR-PRIMARY-PATH { | | grouping TE-SR-PRIMARY-PATH { |
| description | | description |
| "Segment-Routing primary path"; | | "Segment-Routing primary path"; |
| leaf outgoing-interface { | | leaf outgoing-interface { |
| type string; | | type string; |
| description | | description |
| "Outgoing Interface Name"; | | "Outgoing Interface Name"; |
| } | | } |
| leaf outgoing-label { | | leaf outgoing-label { |
| type uint32; | | type uint32; |
| description | | description |
| "Outgoing Label"; | | "Outgoing Label"; |
| } | | } |
| leaf outgoing-strict-label { | | leaf outgoing-strict-label { |
| type uint32; | | type uint32; |
| description | | description |
| "Outgoing Label for Strict SPF"; | | "Outgoing Label for Strict SPF"; |
| } | | } |
| leaf next-hop { | | leaf next-hop { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Next hop"; | | "Next hop"; |
| } | | } |
| leaf path-id { | | leaf path-id { |
| type uint32; | | type uint32; |
| description | | description |
| "Path Identifier"; | | "Path Identifier"; |
| } | | } |
| leaf backup-path-id { | | leaf backup-path-id { |
| type uint32; | | type uint32; |
| description | | description |
| "Backup Path Identifier"; | | "Backup Path Identifier"; |
| } | | } |
| } | | } |
| | | |
| grouping TE-SR-PATH { | | grouping TE-SR-PATH { |
| description | | description |
| "Segment-Routing path"; | | "Segment-Routing path"; |
| container primary-path { | | container primary-path { |
| description | | description |
| "Primary Segment-Routing Path"; | | "Primary Segment-Routing Path"; |
| uses TE-SR-PRIMARY-PATH; | | uses TE-SR-PRIMARY-PATH; |
| } | | } |
| container backup-path { | | container backup-path { |
| description | | description |
| "Backup Segment-Routing Path"; | | "Backup Segment-Routing Path"; |
| uses TE-SR-BACKUP-PATH; | | uses TE-SR-BACKUP-PATH; |
| } | | } |
| leaf has-backup-path { | | leaf has-backup-path { |
| type boolean; | | type boolean; |
| description | | description |
| "Backup Path is available"; | | "Backup Path is available"; |
| } | | } |
| } | | } |
| | | |
| grouping TE-SR-PREFIX { | | grouping TE-SR-PREFIX { |
| description | | description |
| "MPLS TE Segment-Routing Prefix information"; | | "MPLS TE Segment-Routing Prefix information"; |
| container igp-area { | | container igp-area { |
| description | | description |
| "An IGP area where the prefix belongs to"; | | "An IGP area where the prefix belongs to"; |
| uses TE-SR-IGP-AREA; | | uses TE-SR-IGP-AREA; |
| } | | } |
| leaf prefix-xr { | | leaf prefix-xr { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Prefix"; | | "Prefix"; |
| } | | } |
| leaf prefix-length-xr { | | leaf prefix-length-xr { |
| type uint8; | | type uint8; |
| description | | description |
| "Length of the prefix"; | | "Length of the prefix"; |
| } | | } |
| leaf prefix-sid { | | leaf prefix-sid { |
| type uint32; | | type uint32; |
| description | | description |
| "Segment-Routing prefix SID"; | | "Segment-Routing prefix SID"; |
| } | | } |
| leaf prefix-strict-sid { | | leaf prefix-strict-sid { |
| type uint32; | | type uint32; |
| description | | description |
| "Segment-Routing prefix Strict SID"; | | "Segment-Routing prefix Strict SID"; |
| } | | } |
| leaf flag-r { | | leaf flag-r { |
| type boolean; | | type boolean; |
| description | | description |
| "Prefix-SID subTLV R-flag"; | | "Prefix-SID subTLV R-flag"; |
| } | | } |
| leaf flag-n { | | leaf flag-n { |
| type boolean; | | type boolean; |
| description | | description |
| "Prefix-SID subTLV N-flag"; | | "Prefix-SID subTLV N-flag"; |
| } | | } |
| leaf flag-p { | | leaf flag-p { |
| type boolean; | | type boolean; |
| description | | description |
| "Prefix-SID subTLV P-flag"; | | "Prefix-SID subTLV P-flag"; |
| } | | } |
| leaf flag-e { | | leaf flag-e { |
| type boolean; | | type boolean; |
| description | | description |
| "Prefix-SID subTLV E-flag"; | | "Prefix-SID subTLV E-flag"; |
| } | | } |
| leaf flag-v { | | leaf flag-v { |
| type boolean; | | type boolean; |
| description | | description |
| "Prefix-SID subTLV V-flag"; | | "Prefix-SID subTLV V-flag"; |
| } | | } |
| leaf flag-l { | | leaf flag-l { |
| type boolean; | | type boolean; |
| description | | description |
| "Prefix-SID subTLV L-flag"; | | "Prefix-SID subTLV L-flag"; |
| } | | } |
| leaf strict-flag-p { | | leaf strict-flag-p { |
| type boolean; | | type boolean; |
| description | | description |
| "Prefix-SID subTLV P-flag for strict SID"; | | "Prefix-SID subTLV P-flag for strict SID"; |
| } | | } |
| leaf strict-flag-e { | | leaf strict-flag-e { |
| type boolean; | | type boolean; |
| description | | description |
| "Prefix-SID subTLV E-flag for strict SID"; | | "Prefix-SID subTLV E-flag for strict SID"; |
| } | | } |
| leaf strict-flag-v { | | leaf strict-flag-v { |
| type boolean; | | type boolean; |
| description | | description |
| "Prefix-SID subTLV V-flag for strict SID"; | | "Prefix-SID subTLV V-flag for strict SID"; |
| } | | } |
| leaf strict-flag-l { | | leaf strict-flag-l { |
| type boolean; | | type boolean; |
| description | | description |
| "Prefix-SID subTLV L-flag for strict SID"; | | "Prefix-SID subTLV L-flag for strict SID"; |
| } | | } |
| list sr-path { | | list sr-path { |
| description | | description |
| "Segment-Routing paths to prefix"; | | "Segment-Routing paths to prefix"; |
| uses TE-SR-PATH; | | uses TE-SR-PATH; |
| } | | } |
| list advertizing-node { | | list advertizing-node { |
| description | | description |
| "Advertizing nodes"; | | "Advertizing nodes"; |
| uses NODE-ID; | | uses NODE-ID; |
| } | | } |
| list strict-advertizing-node { | | list strict-advertizing-node { |
| description | | description |
| "Advertizing nodes for Strict SPF"; | | "Advertizing nodes for Strict SPF"; |
| uses NODE-ID; | | uses NODE-ID; |
| } | | } |
| } | | } |
| | | |
| grouping TE-SR-ADJ-SID { | | grouping TE-SR-ADJ-SID { |
| description | | description |
| "A link's Segment-Routing Adjacency information"; | | "A link's Segment-Routing Adjacency information"; |
| leaf adjacency-sid { | | leaf adjacency-sid { |
| type uint32; | | type uint32; |
| description | | description |
| "The adjacency SID assigned for the topology node"; | | "The adjacency SID assigned for the topology node"; |
| } | | } |
| leaf link-type { | | leaf link-type { |
| type Igp-subnet; | | type Igp-subnet; |
| description | | description |
| "Link Type"; | | "Link Type"; |
| } | | } |
| leaf local-addr { | | leaf local-addr { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Local Address"; | | "Local Address"; |
| } | | } |
| leaf remote-addr { | | leaf remote-addr { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Remote Address"; | | "Remote Address"; |
| } | | } |
| leaf nbr-node-igpid { | | leaf nbr-node-igpid { |
| type string; | | type string; |
| description | | description |
| "The neighbor node's IGP ID"; | | "The neighbor node's IGP ID"; |
| } | | } |
| leaf nbr-node-te-router-id { | | leaf nbr-node-te-router-id { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "The neigbor node's TE router-id"; | | "The neigbor node's TE router-id"; |
| } | | } |
| leaf flag-f { | | leaf flag-f { |
| type boolean; | | type boolean; |
| description | | description |
| "IGP Flag F"; | | "IGP Flag F"; |
| } | | } |
| leaf flag-b { | | leaf flag-b { |
| type boolean; | | type boolean; |
| description | | description |
| "IGP Flag B"; | | "IGP Flag B"; |
| } | | } |
| leaf flag-v { | | leaf flag-v { |
| type boolean; | | type boolean; |
| description | | description |
| "IGP Flag V"; | | "IGP Flag V"; |
| } | | } |
| leaf flag-l { | | leaf flag-l { |
| type boolean; | | type boolean; |
| description | | description |
| "IGP Flag L"; | | "IGP Flag L"; |
| } | | } |
| leaf flag-s { | | leaf flag-s { |
| type boolean; | | type boolean; |
| description | | description |
| "IGP Flag S"; | | "IGP Flag S"; |
| } | | } |
| } | | } |
| | | |
| grouping TE-SR-LINK-INFO { | | grouping TE-SR-LINK-INFO { |
| description | | description |
| "A link belonging to a node"; | | "A link belonging to a node"; |
| leaf topology-link-type { | | leaf topology-link-type { |
| type Igp-subnet; | | type Igp-subnet; |
| description | | description |
| "Link type"; | | "Link type"; |
| } | | } |
| leaf topology-link-interface-address { | | leaf topology-link-interface-address { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Link's local interface address"; | | "Link's local interface address"; |
| } | | } |
| leaf topology-link-interface-id { | | leaf topology-link-interface-id { |
| type uint32; | | type uint32; |
| description | | description |
| "Link's local interface ID"; | | "Link's local interface ID"; |
| } | | } |
| leaf topology-link-neighbor-address { | | leaf topology-link-neighbor-address { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Link's neighbor interface address"; | | "Link's neighbor interface address"; |
| } | | } |
| leaf topology-link-neighbor-id { | | leaf topology-link-neighbor-id { |
| type uint32; | | type uint32; |
| description | | description |
| "Link's neighbor interface ID"; | | "Link's neighbor interface ID"; |
| } | | } |
| leaf topology-link-neighbor-system-id { | | leaf topology-link-neighbor-system-id { |
| type string; | | type string; |
| description | | description |
| "System id of neighbor"; | | "System id of neighbor"; |
| } | | } |
| leaf topology-link-neighbor-node-id { | | leaf topology-link-neighbor-node-id { |
| type uint32; | | type uint32; |
| description | | description |
| "Node id of neighbor"; | | "Node id of neighbor"; |
| } | | } |
| leaf topology-link-neighbor-generation { | | leaf topology-link-neighbor-generation { |
| type uint32; | | type uint32; |
| description | | description |
| "Neighbor's link version counter"; | | "Neighbor's link version counter"; |
| } | | } |
| leaf topology-link-fragment-id { | | leaf topology-link-fragment-id { |
| type uint32; | | type uint32; |
| description | | description |
| "Neighbor's link version counter"; | | "Neighbor's link version counter"; |
| } | | } |
| leaf topology-link-te-metric { | | leaf topology-link-te-metric { |
| type uint32; | | type uint32; |
| description | | description |
| "The link's TE metric"; | | "The link's TE metric"; |
| } | | } |
| leaf topology-link-igp-metric { | | leaf topology-link-igp-metric { |
| type uint32; | | type uint32; |
| description | | description |
| "The link's IGP metric"; | | "The link's IGP metric"; |
| } | | } |
| list topology-link-extended-affinity-bit { | | list topology-link-extended-affinity-bit { |
| description | | description |
| "The link's affinity bits (colors)"; | | "The link's affinity bits (colors)"; |
| leaf entry { | | leaf entry { |
| type uint32; | | type uint32; |
| description | | description |
| "The link's affinity bits (colors)"; | | "The link's affinity bits (colors)"; |
| } | | } |
| } | | } |
| list shared-risk-link-group { | | list shared-risk-link-group { |
| description | | description |
| "The link's shared risk link groups"; | | "The link's shared risk link groups"; |
| uses MPLS-SRLG-INFO; | | uses MPLS-SRLG-INFO; |
| } | | } |
| list adjacency-sids { | | list adjacency-sids { |
| description | | description |
| "Adjacency SIDs assigned for adjacency nodes"; | | "Adjacency SIDs assigned for adjacency nodes"; |
| uses TE-SR-ADJ-SID; | | uses TE-SR-ADJ-SID; |
| } | | } |
| } | | } |
| | | |
| grouping TE-SR-NODE-INFO { | | grouping TE-SR-NODE-INFO { |
| description | | description |
| "MPLS TE Node's Segment-Routing Information"; | | "MPLS TE Node's Segment-Routing Information"; |
| leaf segment-id { | | leaf segment-id { |
| type uint32; | | type uint32; |
| description | | description |
| "Segment-Routing Node-SID"; | | "Segment-Routing Node-SID"; |
| } | | } |
| leaf segment-id-local-absolute-value { | | leaf segment-id-local-absolute-value { |
| type uint32; | | type uint32; |
| description | | description |
| "Node-SID local absolute value"; | | "Node-SID local absolute value"; |
| } | | } |
| leaf srgb-start { | | leaf srgb-start { |
| type uint32; | | type uint32; |
| description | | description |
| "Segment-Routring global block start value"; | | "Segment-Routring global block start value"; |
| } | | } |
| leaf srgb-size { | | leaf srgb-size { |
| type uint32; | | type uint32; |
| description | | description |
| "Segment-Routing global block size"; | | "Segment-Routing global block size"; |
| } | | } |
| } | | } |
| | | |
| grouping TE-SR-NODE { | | grouping TE-SR-NODE { |
| description | | description |
| "MPLS TE Segment-Routing Node topology information"; | | "MPLS TE Segment-Routing Node topology information"; |
| container igp-area { | | container igp-area { |
| description | | description |
| "IGP area which this node belongs to"; | | "IGP area which this node belongs to"; |
| uses TE-SR-IGP-AREA; | | uses TE-SR-IGP-AREA; |
| } | | } |
| container sr-node-info { | | container sr-node-info { |
| description | | description |
| "Segment-Routing Node information"; | | "Segment-Routing Node information"; |
| uses TE-SR-NODE-INFO; | | uses TE-SR-NODE-INFO; |
| } | | } |
| leaf local-node-igp-id { | | leaf local-node-igp-id { |
| type string; | | type string; |
| description | | description |
| "The local node's IGP id formatted as string"; | | "The local node's IGP id formatted as string"; |
| } | | } |
| leaf topology-node-is-router { | | leaf topology-node-is-router { |
| type boolean; | | type boolean; |
| description | | description |
| "TRUE if this is a router node; FALSE if it's a | | "TRUE if this is a router node; FALSE if it's a |
| network node"; | | network node"; |
| } | | } |
| leaf local-node-te-router-id { | | leaf local-node-te-router-id { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "The local node's TE router-id"; | | "The local node's TE router-id"; |
| } | | } |
| leaf topology-node-overloaded { | | leaf topology-node-overloaded { |
| type boolean; | | type boolean; |
| description | | description |
| "Flag to indicate whether this node is overloaded"; | | "Flag to indicate whether this node is overloaded"; |
| } | | } |
| list node-link { | | list node-link { |
| description | | description |
| "This node's link information"; | | "This node's link information"; |
| uses TE-SR-LINK-INFO; | | uses TE-SR-LINK-INFO; |
| } | | } |
| } | | } |
| | | |
| grouping TE-SR-IGP-AREA { | | grouping TE-SR-IGP-AREA { |
| description | | description |
| "A IGP area information for Segment-Routing"; | | "A IGP area information for Segment-Routing"; |
| leaf segment-routing-enabled { | | leaf segment-routing-enabled { |
| type boolean; | | type boolean; |
| description | | description |
| "True if the Segment-Routing is enabled in this | | "True if the Segment-Routing is enabled in this |
| area"; | | area"; |
| } | | } |
| leaf strict-spf-enabled { | | leaf strict-spf-enabled { |
| type boolean; | | type boolean; |
| description | | description |
| "True if the strict SPF is enabled in this area"; | | "True if the strict SPF is enabled in this area"; |
| } | | } |
| leaf igp-type { | | leaf igp-type { |
| type Igp-protocol; | | type Igp-protocol; |
| description | | description |
| "IGP type"; | | "IGP type"; |
| } | | } |
| leaf igp-instance-xr { | | leaf igp-instance-xr { |
| type string; | | type string; |
| description | | description |
| "IGP Instance name"; | | "IGP Instance name"; |
| } | | } |
| leaf igp-area { | | leaf igp-area { |
| type uint32; | | type uint32; |
| description | | description |
| "IGP Area ID"; | | "IGP Area ID"; |
| } | | } |
| leaf igp-area-format { | | leaf igp-area-format { |
| type Igp-ospf-area-format; | | type Igp-ospf-area-format; |
| description | | description |
| "IGP-area format"; | | "IGP-area format"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-STICKY-PATH { | | grouping MPLS-TE-STICKY-PATH { |
| description | | description |
| "TE sticky path"; | | "TE sticky path"; |
| leaf path-option-id { | | leaf path-option-id { |
| type uint16; | | type uint16; |
| description | | description |
| "Path-option preference level"; | | "Path-option preference level"; |
| } | | } |
| list path { | | list path { |
| description | | description |
| "Path ERO"; | | "Path ERO"; |
| uses RSVP-MGMT-ERO-SUBOBJ; | | uses RSVP-MGMT-ERO-SUBOBJ; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-TUNNEL-FLEX-INFO { | | grouping MPLS-TE-TUNNEL-FLEX-INFO { |
| description | | description |
| "TE Tunnel FlexLSP Information"; | | "TE Tunnel FlexLSP Information"; |
| leaf fault-ldi-lockout { | | leaf fault-ldi-lockout { |
| type boolean; | | type boolean; |
| description | | description |
| "Fault LDI Lockout"; | | "Fault LDI Lockout"; |
| } | | } |
| leaf fault-ldi { | | leaf fault-ldi { |
| type boolean; | | type boolean; |
| description | | description |
| "Fault LDI"; | | "Fault LDI"; |
| } | | } |
| leaf fault-lkr { | | leaf fault-lkr { |
| type boolean; | | type boolean; |
| description | | description |
| "Fault LKR"; | | "Fault LKR"; |
| } | | } |
| leaf fault-ais { | | leaf fault-ais { |
| type boolean; | | type boolean; |
| description | | description |
| "Fault AIS"; | | "Fault AIS"; |
| } | | } |
| leaf fault-time { | | leaf fault-time { |
| type uint32; | | type uint32; |
| description | | description |
| "Fault Time"; | | "Fault Time"; |
| } | | } |
| leaf fault-in-label { | | leaf fault-in-label { |
| type uint32; | | type uint32; |
| description | | description |
| "Fault In Label"; | | "Fault In Label"; |
| } | | } |
| leaf is-lockout { | | leaf is-lockout { |
| type boolean; | | type boolean; |
| description | | description |
| "Lockout Status"; | | "Lockout Status"; |
| } | | } |
| leaf lockout-timestamp { | | leaf lockout-timestamp { |
| type uint32; | | type uint32; |
| description | | description |
| "The timestamp when the lockout is set"; | | "The timestamp when the lockout is set"; |
| } | | } |
| leaf lockout-lsp-id { | | leaf lockout-lsp-id { |
| type uint16; | | type uint16; |
| description | | description |
| "The LSP ID of the locked out LSP"; | | "The LSP ID of the locked out LSP"; |
| } | | } |
| leaf origination { | | leaf origination { |
| type Flex-lsp-lockout-origination; | | type Flex-lsp-lockout-origination; |
| description | | description |
| "Flex LSP Lockout Origination Source"; | | "Flex LSP Lockout Origination Source"; |
| } | | } |
| } | | } |
| | | |
| grouping TE-VIF-CONVERGENCE-INFO { | | grouping TE-VIF-CONVERGENCE-INFO { |
| description | | description |
| "TE tunnel convergence related information"; | | "TE tunnel convergence related information"; |
| container convergence-lsp { | | container convergence-lsp { |
| description | | description |
| "TE LSP convergence related information"; | | "TE LSP convergence related information"; |
| uses TE-LSP-CONVERGENCE-INFO; | | uses TE-LSP-CONVERGENCE-INFO; |
| } | | } |
| leaf is-convergence-in-progress { | | leaf is-convergence-in-progress { |
| type boolean; | | type boolean; |
| description | | description |
| "TE convergence in progress"; | | "TE convergence in progress"; |
| } | | } |
| leaf frr-trigger-time { | | leaf frr-trigger-time { |
| type uint64; | | type uint64; |
| description | | description |
| "FRR trigger time"; | | "FRR trigger time"; |
| } | | } |
| leaf pcalc-complete-time { | | leaf pcalc-complete-time { |
| type uint64; | | type uint64; |
| units "nanosecond"; | | units "nanosecond"; |
| description | | description |
| "Path computation completion timestamp (clocktime | | "Path computation completion timestamp (clocktime |
| in nsecs)"; | | in nsecs)"; |
| } | | } |
| leaf convergence-complete-time { | | leaf convergence-complete-time { |
| type uint64; | | type uint64; |
| description | | description |
| "TE convergence completion time"; | | "TE convergence completion time"; |
| } | | } |
| leaf binding-label-rewrite-time { | | leaf binding-label-rewrite-time { |
| type uint64; | | type uint64; |
| units "nanosecond"; | | units "nanosecond"; |
| description | | description |
| "Binding label timestamp (clocktime in nsecs)"; | | "Binding label timestamp (clocktime in nsecs)"; |
| } | | } |
| leaf vif-creation-time { | | leaf vif-creation-time { |
| type uint64; | | type uint64; |
| units "nanosecond"; | | units "nanosecond"; |
| description | | description |
| "Vif creation timestamp (clocktime in nsecs)"; | | "Vif creation timestamp (clocktime in nsecs)"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-TUNNELS-REVERSE-ERO-ERROR-BAG { | | grouping MPLS-TE-TUNNELS-REVERSE-ERO-ERROR-BAG { |
| description | | description |
| "MPLS TE Tunnel Reverse ERO Error Information"; | | "MPLS TE Tunnel Reverse ERO Error Information"; |
| leaf reverse-lsp-id { | | leaf reverse-lsp-id { |
| type uint16; | | type uint16; |
| description | | description |
| "Reverse LSP ID"; | | "Reverse LSP ID"; |
| } | | } |
| leaf path-reject-reason-bw { | | leaf path-reject-reason-bw { |
| type boolean; | | type boolean; |
| description | | description |
| "Path Reject due to bw"; | | "Path Reject due to bw"; |
| } | | } |
| leaf path-reject-reason-affinity { | | leaf path-reject-reason-affinity { |
| type boolean; | | type boolean; |
| description | | description |
| "Path Reject due to affinity"; | | "Path Reject due to affinity"; |
| } | | } |
| leaf path-reject-reason-ip-addr { | | leaf path-reject-reason-ip-addr { |
| type boolean; | | type boolean; |
| description | | description |
| "Path Reject due to IP address"; | | "Path Reject due to IP address"; |
| } | | } |
| leaf path-reject-reason-reverse-link { | | leaf path-reject-reason-reverse-link { |
| type boolean; | | type boolean; |
| description | | description |
| "Path Reject due to reverse link"; | | "Path Reject due to reverse link"; |
| } | | } |
| leaf path-reject-reason-ixcd { | | leaf path-reject-reason-ixcd { |
| type boolean; | | type boolean; |
| description | | description |
| "Path Reject due to IXCD"; | | "Path Reject due to IXCD"; |
| } | | } |
| leaf path-reject-reason-holddown { | | leaf path-reject-reason-holddown { |
| type boolean; | | type boolean; |
| description | | description |
| "Path Reject due to holddown"; | | "Path Reject due to holddown"; |
| } | | } |
| leaf path-reject-reason-exclude-node { | | leaf path-reject-reason-exclude-node { |
| type boolean; | | type boolean; |
| description | | description |
| "Path Reject due to exclude node"; | | "Path Reject due to exclude node"; |
| } | | } |
| leaf path-reject-reason-exclude-link { | | leaf path-reject-reason-exclude-link { |
| type boolean; | | type boolean; |
| description | | description |
| "Path Reject due to exclude link"; | | "Path Reject due to exclude link"; |
| } | | } |
| leaf path-reject-reason-exclude-srlg { | | leaf path-reject-reason-exclude-srlg { |
| type boolean; | | type boolean; |
| description | | description |
| "Path Reject due to exclude SRLG"; | | "Path Reject due to exclude SRLG"; |
| } | | } |
| leaf path-reject-reason-hop-limit { | | leaf path-reject-reason-hop-limit { |
| type boolean; | | type boolean; |
| description | | description |
| "Path Reject due to hop limit"; | | "Path Reject due to hop limit"; |
| } | | } |
| leaf path-reject-reason-node-ol-unknown { | | leaf path-reject-reason-node-ol-unknown { |
| type boolean; | | type boolean; |
| description | | description |
| "Path Reject due to unknown node overload"; | | "Path Reject due to unknown node overload"; |
| } | | } |
| leaf path-reject-reason-node-ol-head { | | leaf path-reject-reason-node-ol-head { |
| type boolean; | | type boolean; |
| description | | description |
| "Path Reject due to head node overload"; | | "Path Reject due to head node overload"; |
| } | | } |
| leaf path-reject-reason-node-ol-mid { | | leaf path-reject-reason-node-ol-mid { |
| type boolean; | | type boolean; |
| description | | description |
| "Path Reject due to mid node overload"; | | "Path Reject due to mid node overload"; |
| } | | } |
| leaf path-reject-reason-node-ol-tail { | | leaf path-reject-reason-node-ol-tail { |
| type boolean; | | type boolean; |
| description | | description |
| "Path Reject due to head node overload"; | | "Path Reject due to head node overload"; |
| } | | } |
| leaf path-reject-reason-reverse-bw { | | leaf path-reject-reason-reverse-bw { |
| type boolean; | | type boolean; |
| description | | description |
| "Path Reject due to reverse bw"; | | "Path Reject due to reverse bw"; |
| } | | } |
| leaf path-reject-reason-node-unreachable { | | leaf path-reject-reason-node-unreachable { |
| type boolean; | | type boolean; |
| description | | description |
| "Path Reject due to unreachable node"; | | "Path Reject due to unreachable node"; |
| } | | } |
| leaf path-option-index { | | leaf path-option-index { |
| type uint16; | | type uint16; |
| description | | description |
| "Path Option Index"; | | "Path Option Index"; |
| } | | } |
| leaf path-option-type { | | leaf path-option-type { |
| type Mte-path-option; | | type Mte-path-option; |
| description | | description |
| "Path Option Type"; | | "Path Option Type"; |
| } | | } |
| leaf ero-reject-reason { | | leaf ero-reject-reason { |
| type Te-rev-ero-reject-reasons; | | type Te-rev-ero-reject-reasons; |
| description | | description |
| "Reverse ERO Reject Reason"; | | "Reverse ERO Reject Reason"; |
| } | | } |
| list path-calculation-error { | | list path-calculation-error { |
| description | | description |
| "Path Computation Information"; | | "Path Computation Information"; |
| uses MPLS-TE-P2MP-PCALC-ERROR; | | uses MPLS-TE-P2MP-PCALC-ERROR; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-TUNNEL-BIDIR-INFO { | | grouping MPLS-TE-TUNNEL-BIDIR-INFO { |
| description | | description |
| "MPLS TE Tunnel Bidir Information"; | | "MPLS TE Tunnel Bidir Information"; |
| container reverse-ero-error-current { | | container reverse-ero-error-current { |
| description | | description |
| "Reverse ERO Error Current LSP"; | | "Reverse ERO Error Current LSP"; |
| uses MPLS-TE-TUNNELS-REVERSE-ERO-ERROR-BAG; | | uses MPLS-TE-TUNNELS-REVERSE-ERO-ERROR-BAG; |
| } | | } |
| container reverse-ero-error-reopt { | | container reverse-ero-error-reopt { |
| description | | description |
| "Reverse ERO Error Reopt LSP"; | | "Reverse ERO Error Reopt LSP"; |
| uses MPLS-TE-TUNNELS-REVERSE-ERO-ERROR-BAG; | | uses MPLS-TE-TUNNELS-REVERSE-ERO-ERROR-BAG; |
| } | | } |
| container reverse-ero-error-standby { | | container reverse-ero-error-standby { |
| description | | description |
| "Reverse ERO Error Standby LSP"; | | "Reverse ERO Error Standby LSP"; |
| uses MPLS-TE-TUNNELS-REVERSE-ERO-ERROR-BAG; | | uses MPLS-TE-TUNNELS-REVERSE-ERO-ERROR-BAG; |
| } | | } |
| container reverse-ero-error-standby-reopt { | | container reverse-ero-error-standby-reopt { |
| description | | description |
| "Reverse ERO Error Standby Reopt LSP"; | | "Reverse ERO Error Standby Reopt LSP"; |
| uses MPLS-TE-TUNNELS-REVERSE-ERO-ERROR-BAG; | | uses MPLS-TE-TUNNELS-REVERSE-ERO-ERROR-BAG; |
| } | | } |
| leaf reverse-bandwidth { | | leaf reverse-bandwidth { |
| type uint32; | | type uint32; |
| units "kbit/s"; | | units "kbit/s"; |
| description | | description |
| "Reverse Bandwidth value in kbps"; | | "Reverse Bandwidth value in kbps"; |
| } | | } |
| leaf reverse-bandwidth-standby { | | leaf reverse-bandwidth-standby { |
| type uint32; | | type uint32; |
| units "kbit/s"; | | units "kbit/s"; |
| description | | description |
| "Reverse Bandwidth value for standby in kbps"; | | "Reverse Bandwidth value for standby in kbps"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-TUNNEL-RESTORATION-INFO { | | grouping MPLS-TE-TUNNEL-RESTORATION-INFO { |
| description | | description |
| "Restoration info of tunnel"; | | "Restoration info of tunnel"; |
| leaf revert-option { | | leaf revert-option { |
| type Te-pnr-revert-options; | | type Te-pnr-revert-options; |
| description | | description |
| "Revertive or non-revertive"; | | "Revertive or non-revertive"; |
| } | | } |
| leaf diverse-lsp { | | leaf diverse-lsp { |
| type Mpls-te-lsp-mode; | | type Mpls-te-lsp-mode; |
| description | | description |
| "LSP from which restoration LSP is DIVERSED"; | | "LSP from which restoration LSP is DIVERSED"; |
| } | | } |
| leaf diversity-type { | | leaf diversity-type { |
| type Te-pp-diversity; | | type Te-pp-diversity; |
| description | | description |
| "Restoration path diversity type"; | | "Restoration path diversity type"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-TUNNEL-APS-INFO { | | grouping MPLS-TE-TUNNEL-APS-INFO { |
| description | | description |
| "APS Protection Info of tunnel"; | | "APS Protection Info of tunnel"; |
| container protection-profile { | | container protection-profile { |
| description | | description |
| "Protection Profile Information of tunnel"; | | "Protection Profile Information of tunnel"; |
| uses MPLS-TE-ATTRIBUTE-SET-APS-PP; | | uses MPLS-TE-ATTRIBUTE-SET-APS-PP; |
| } | | } |
| leaf active-lsp { | | leaf active-lsp { |
| type Mpls-te-lsp-mode; | | type Mpls-te-lsp-mode; |
| description | | description |
| "Active LSP for Incoming Data"; | | "Active LSP for Incoming Data"; |
| } | | } |
| leaf diversity-type { | | leaf diversity-type { |
| type Te-pp-diversity; | | type Te-pp-diversity; |
| description | | description |
| "Standby path diversity type"; | | "Standby path diversity type"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-TUNNEL-OTN-BIDIR-INFO { | | grouping MPLS-TE-TUNNEL-OTN-BIDIR-INFO { |
| description | | description |
| "Bidirectional Tunnel Information"; | | "Bidirectional Tunnel Information"; |
| container aps { | | container aps { |
| description | | description |
| "APS Protection Info"; | | "APS Protection Info"; |
| uses MPLS-TE-TUNNEL-APS-INFO; | | uses MPLS-TE-TUNNEL-APS-INFO; |
| } | | } |
| container restoration { | | container restoration { |
| description | | description |
| "Restoration Info"; | | "Restoration Info"; |
| uses MPLS-TE-TUNNEL-RESTORATION-INFO; | | uses MPLS-TE-TUNNEL-RESTORATION-INFO; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-PATH-OPTION-DAMPENING-INFO { | | grouping MPLS-TE-PATH-OPTION-DAMPENING-INFO { |
| description | | description |
| "MPLS TE Path Option Dampening Information"; | | "MPLS TE Path Option Dampening Information"; |
| leaf option-index { | | leaf option-index { |
| type uint32; | | type uint32; |
| description | | description |
| "Path option index"; | | "Path option index"; |
| } | | } |
| leaf hold-down-time { | | leaf hold-down-time { |
| type uint32; | | type uint32; |
| description | | description |
| "Hold down time in second"; | | "Hold down time in second"; |
| } | | } |
| leaf remained-time { | | leaf remained-time { |
| type uint32; | | type uint32; |
| description | | description |
| "Remained time to resignal in second"; | | "Remained time to resignal in second"; |
| } | | } |
| leaf backoff-count { | | leaf backoff-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Backoff count"; | | "Backoff count"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-TUNNEL-BFD-INFO { | | grouping MPLS-TE-TUNNEL-BFD-INFO { |
| description | | description |
| "MPLS TE Tunnel BFD Session Information"; | | "MPLS TE Tunnel BFD Session Information"; |
| container event-counters { | | container event-counters { |
| description | | description |
| "Per tunnel BFD session event counters"; | | "Per tunnel BFD session event counters"; |
| uses MPLS-TE-BFD-LSP-COUNTERS; | | uses MPLS-TE-BFD-LSP-COUNTERS; |
| } | | } |
| leaf bfd-session-up { | | leaf bfd-session-up { |
| type boolean; | | type boolean; |
| description | | description |
| "Tunnel BFD session state up or down"; | | "Tunnel BFD session state up or down"; |
| } | | } |
| leaf session-up-time { | | leaf session-up-time { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Time in seconds since the last session state up"; | | "Time in seconds since the last session state up"; |
| } | | } |
| leaf failure-diagnostic-code { | | leaf failure-diagnostic-code { |
| type uint32; | | type uint32; |
| description | | description |
| "BFD session failure diagnostic code"; | | "BFD session failure diagnostic code"; |
| } | | } |
| leaf failure-reason { | | leaf failure-reason { |
| type string; | | type string; |
| description | | description |
| "BFD session failure reason"; | | "BFD session failure reason"; |
| } | | } |
| leaf minimum-session-up-interval { | | leaf minimum-session-up-interval { |
| type uint32; | | type uint32; |
| description | | description |
| "Minimum time in mini second for session to come | | "Minimum time in mini second for session to come |
| up"; | | up"; |
| } | | } |
| leaf maximum-session-up-interval { | | leaf maximum-session-up-interval { |
| type uint32; | | type uint32; |
| description | | description |
| "Maximum time in mini second for session to come | | "Maximum time in mini second for session to come |
| up"; | | up"; |
| } | | } |
| list dampening-info { | | list dampening-info { |
| description | | description |
| "Path option dampening info"; | | "Path option dampening info"; |
| uses MPLS-TE-PATH-OPTION-DAMPENING-INFO; | | uses MPLS-TE-PATH-OPTION-DAMPENING-INFO; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-TUNNEL-VIF-DIVERSITY-INFO { | | grouping MPLS-TE-TUNNEL-VIF-DIVERSITY-INFO { |
| description | | description |
| "Circuit diversity information"; | | "Circuit diversity information"; |
| leaf tunnel-id { | | leaf tunnel-id { |
| type uint16; | | type uint16; |
| description | | description |
| "Dependent Tunnel ID"; | | "Dependent Tunnel ID"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-TUNNEL-STATIC-UNI-INFO { | | grouping MPLS-TE-TUNNEL-STATIC-UNI-INFO { |
| description | | description |
| "static UNI info for both head and tail"; | | "static UNI info for both head and tail"; |
| container term-interface-srlg { | | container term-interface-srlg { |
| description | | description |
| "Termination Interface SRLG"; | | "Termination Interface SRLG"; |
| uses TE-TERM-INTERFACE-SRLG-CB; | | uses TE-TERM-INTERFACE-SRLG-CB; |
| } | | } |
| leaf client-port { | | leaf client-port { |
| type string; | | type string; |
| description | | description |
| "Ingress Client Port"; | | "Ingress Client Port"; |
| } | | } |
| leaf client-if-handle { | | leaf client-if-handle { |
| type xr:Interface-name; | | type xr:Interface-name; |
| description | | description |
| "Ingress Client Port Ifhandle"; | | "Ingress Client Port Ifhandle"; |
| } | | } |
| leaf client-odu-name { | | leaf client-odu-name { |
| type string; | | type string; |
| description | | description |
| "Client Odu Name"; | | "Client Odu Name"; |
| } | | } |
| leaf client-odu-if-handle { | | leaf client-odu-if-handle { |
| type xr:Interface-name; | | type xr:Interface-name; |
| description | | description |
| "Client Odu Interface"; | | "Client Odu Interface"; |
| } | | } |
| leaf cross-connect-id { | | leaf cross-connect-id { |
| type uint32; | | type uint32; |
| description | | description |
| "Cross connect id"; | | "Cross connect id"; |
| } | | } |
| leaf is-connected { | | leaf is-connected { |
| type boolean; | | type boolean; |
| description | | description |
| "True if client port is connected"; | | "True if client port is connected"; |
| } | | } |
| leaf uptime { | | leaf uptime { |
| type uint32; | | type uint32; |
| description | | description |
| "Client Port Uptime"; | | "Client Port Uptime"; |
| } | | } |
| leaf local-termination { | | leaf local-termination { |
| type Mpls-te-termination; | | type Mpls-te-termination; |
| description | | description |
| "Local Termination Type"; | | "Local Termination Type"; |
| } | | } |
| leaf static-uni-type { | | leaf static-uni-type { |
| type Mpls-te-uni; | | type Mpls-te-uni; |
| description | | description |
| "Static uni type"; | | "Static uni type"; |
| } | | } |
| leaf term-client-port { | | leaf term-client-port { |
| type string; | | type string; |
| description | | description |
| "Termination Ingress Client Port"; | | "Termination Ingress Client Port"; |
| } | | } |
| leaf term-client-if-handle { | | leaf term-client-if-handle { |
| type xr:Interface-name; | | type xr:Interface-name; |
| description | | description |
| "Termination Ingress Client Port Ifhandle"; | | "Termination Ingress Client Port Ifhandle"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-TUNNEL-OTN-INFO { | | grouping MPLS-TE-TUNNEL-OTN-INFO { |
| description | | description |
| "OTN tunnel's OTN technology information"; | | "OTN tunnel's OTN technology information"; |
| container bandwidth-cfg { | | container bandwidth-cfg { |
| description | | description |
| "Configured OTN Bandwidth for tunnel"; | | "Configured OTN Bandwidth for tunnel"; |
| uses TE-ODU-V3-BW; | | uses TE-ODU-V3-BW; |
| } | | } |
| leaf config-bit-rate { | | leaf config-bit-rate { |
| type uint32; | | type uint32; |
| units "kbit/s"; | | units "kbit/s"; |
| description | | description |
| "Configured OTN Bandwidth in kbps"; | | "Configured OTN Bandwidth in kbps"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-TRANSPORT-TUNNEL-INFO { | | grouping MPLS-TE-TRANSPORT-TUNNEL-INFO { |
| description | | description |
| "Transport Tunnel information"; | | "Transport Tunnel information"; |
| container otn { | | container otn { |
| description | | description |
| "Info Related to OTN technology in S2L"; | | "Info Related to OTN technology in S2L"; |
| uses MPLS-TE-TUNNEL-OTN-INFO; | | uses MPLS-TE-TUNNEL-OTN-INFO; |
| } | | } |
| container static-uni { | | container static-uni { |
| description | | description |
| "Tunnel Static UNI Info"; | | "Tunnel Static UNI Info"; |
| uses MPLS-TE-TUNNEL-STATIC-UNI-INFO; | | uses MPLS-TE-TUNNEL-STATIC-UNI-INFO; |
| } | | } |
| container egress-static-uni { | | container egress-static-uni { |
| description | | description |
| "Tunnel EgressStatic UNI Info"; | | "Tunnel EgressStatic UNI Info"; |
| uses MPLS-TE-TUNNEL-EGRESS-STATIC-UNI-INFO; | | uses MPLS-TE-TUNNEL-EGRESS-STATIC-UNI-INFO; |
| } | | } |
| leaf status-homepath-working { | | leaf status-homepath-working { |
| type boolean; | | type boolean; |
| description | | description |
| "Status of working homepath"; | | "Status of working homepath"; |
| } | | } |
| list homepath-ero { | | list homepath-ero { |
| description | | description |
| "Homepath ero for working lsp"; | | "Homepath ero for working lsp"; |
| uses RSVP-MGMT-ERO-SUBOBJ; | | uses RSVP-MGMT-ERO-SUBOBJ; |
| } | | } |
| list diversity-info { | | list diversity-info { |
| description | | description |
| "Diversity Info"; | | "Diversity Info"; |
| uses MPLS-TE-TUNNEL-VIF-DIVERSITY-INFO; | | uses MPLS-TE-TUNNEL-VIF-DIVERSITY-INFO; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-MGMT-WDM-UNI-TUNNEL-INFO { | | grouping MPLS-TE-MGMT-WDM-UNI-TUNNEL-INFO { |
| description | | description |
| "GMPLS WDM-UNI tunnel information"; | | "GMPLS WDM-UNI tunnel information"; |
| leaf tunnel-state { | | leaf tunnel-state { |
| type Mpls-te-tunnel-state; | | type Mpls-te-tunnel-state; |
| description | | description |
| "Tunnel state"; | | "Tunnel state"; |
| } | | } |
| leaf tunnel-role { | | leaf tunnel-role { |
| type Mpls-te-tunnel-role; | | type Mpls-te-tunnel-role; |
| description | | description |
| "Tunnel Role"; | | "Tunnel Role"; |
| } | | } |
| leaf tunnel-id { | | leaf tunnel-id { |
| type uint16; | | type uint16; |
| description | | description |
| "Tunnel ID"; | | "Tunnel ID"; |
| } | | } |
| leaf lsp-id { | | leaf lsp-id { |
| type uint16; | | type uint16; |
| description | | description |
| "LSP ID"; | | "LSP ID"; |
| } | | } |
| leaf local-optical-router-id { | | leaf local-optical-router-id { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Local optical router id"; | | "Local optical router id"; |
| } | | } |
| leaf remote-optical-router-id { | | leaf remote-optical-router-id { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Remote optical router id"; | | "Remote optical router id"; |
| } | | } |
| leaf controlled-interface { | | leaf controlled-interface { |
| type string; | | type string; |
| description | | description |
| "Interface being controlled"; | | "Interface being controlled"; |
| } | | } |
| leaf source-address { | | leaf source-address { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Source address"; | | "Source address"; |
| } | | } |
| leaf destination-address { | | leaf destination-address { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Destination address"; | | "Destination address"; |
| } | | } |
| leaf extended-tunnel-id { | | leaf extended-tunnel-id { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Extended tunnel-id"; | | "Extended tunnel-id"; |
| } | | } |
| leaf label-origin { | | leaf label-origin { |
| type Mpls-te-mgmt-gmpls-label-origin; | | type Mpls-te-mgmt-gmpls-label-origin; |
| description | | description |
| "Label origin"; | | "Label origin"; |
| } | | } |
| leaf srlg-discovery { | | leaf srlg-discovery { |
| type boolean; | | type boolean; |
| description | | description |
| "SRLG-discovery enabled"; | | "SRLG-discovery enabled"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-SOFT-PREEMPTION-HEAD-COUNTERS { | | grouping MPLS-TE-SOFT-PREEMPTION-HEAD-COUNTERS { |
| description | | description |
| "Headend Soft Preemption Counters"; | | "Headend Soft Preemption Counters"; |
| leaf soft-preemption-events { | | leaf soft-preemption-events { |
| type uint32; | | type uint32; |
| description | | description |
| "The number of soft preemption events"; | | "The number of soft preemption events"; |
| } | | } |
| leaf reopt-completed-ls-ps { | | leaf reopt-completed-ls-ps { |
| type uint32; | | type uint32; |
| description | | description |
| "The number of soft preempted LSPs that were torn | | "The number of soft preempted LSPs that were torn |
| down by the ingress router after the reopt LSP | | down by the ingress router after the reopt LSP |
| was successfully setup."; | | was successfully setup."; |
| } | | } |
| leaf torn-down-ls-ps { | | leaf torn-down-ls-ps { |
| type uint32; | | type uint32; |
| description | | description |
| "The number of soft preempted LSPs that were torn | | "The number of soft preempted LSPs that were torn |
| down by the headend or any remote | | down by the headend or any remote |
| node before the reoptimization is done."; | | node before the reoptimization is done."; |
| } | | } |
| leaf path-protection-switchover-ls-ps { | | leaf path-protection-switchover-ls-ps { |
| type uint32; | | type uint32; |
| description | | description |
| "The number of soft preempted LSPs that were | | "The number of soft preempted LSPs that were |
| switched over to a standby LSP."; | | switched over to a standby LSP."; |
| } | | } |
| leaf frr-triggered-ls-ps { | | leaf frr-triggered-ls-ps { |
| type uint32; | | type uint32; |
| description | | description |
| "The number of soft preempted LSPs that were fast | | "The number of soft preempted LSPs that were fast |
| rerouted at the headend or any | | rerouted at the headend or any |
| remote node before the reoptimization is done."; | | remote node before the reoptimization is done."; |
| } | | } |
| leaf time-in-preemption-pending-min { | | leaf time-in-preemption-pending-min { |
| type uint16; | | type uint16; |
| units "second"; | | units "second"; |
| description | | description |
| "The minimum time in seconds that an LSP was in | | "The minimum time in seconds that an LSP was in |
| preemption pending state"; | | preemption pending state"; |
| } | | } |
| leaf time-in-preemption-pending-max { | | leaf time-in-preemption-pending-max { |
| type uint16; | | type uint16; |
| units "second"; | | units "second"; |
| description | | description |
| "The maximum time in seconds that an LSP was in | | "The maximum time in seconds that an LSP was in |
| preemption pending state"; | | preemption pending state"; |
| } | | } |
| leaf time-in-preemption-pending-avg { | | leaf time-in-preemption-pending-avg { |
| type uint16; | | type uint16; |
| units "second"; | | units "second"; |
| description | | description |
| "The average time in seconds that an LSP was in | | "The average time in seconds that an LSP was in |
| preemption pending state"; | | preemption pending state"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-SOFT-PREEMPTION-PATH-ERROR { | | grouping MPLS-TE-SOFT-PREEMPTION-PATH-ERROR { |
| description | | description |
| "Information for a soft preemption path error"; | | "Information for a soft preemption path error"; |
| leaf timestamp { | | leaf timestamp { |
| type uint32; | | type uint32; |
| description | | description |
| "The POSIX timestamp when the soft preemption | | "The POSIX timestamp when the soft preemption |
| error is received"; | | error is received"; |
| } | | } |
| leaf preempting-link-address { | | leaf preempting-link-address { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "The address of the link where the preemption | | "The address of the link where the preemption |
| happened"; | | happened"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-SOFT-PREEMPTION-TUNNEL-INFO { | | grouping MPLS-TE-SOFT-PREEMPTION-TUNNEL-INFO { |
| description | | description |
| "Headend Soft Preemption Tunnel Info"; | | "Headend Soft Preemption Tunnel Info"; |
| container soft-preemption-counters { | | container soft-preemption-counters { |
| description | | description |
| "The soft preemption counters for this tunnel | | "The soft preemption counters for this tunnel |
| head"; | | head"; |
| uses MPLS-TE-SOFT-PREEMPTION-HEAD-COUNTERS; | | uses MPLS-TE-SOFT-PREEMPTION-HEAD-COUNTERS; |
| } | | } |
| leaf status { | | leaf status { |
| type Mpls-te-soft-preemption-state; | | type Mpls-te-soft-preemption-state; |
| description | | description |
| "The preemption state"; | | "The preemption state"; |
| } | | } |
| leaf time-in-preemption-pending { | | leaf time-in-preemption-pending { |
| type uint16; | | type uint16; |
| units "second"; | | units "second"; |
| description | | description |
| "The number of seconds that were spent in the | | "The number of seconds that were spent in the |
| preemption-pending state"; | | preemption-pending state"; |
| } | | } |
| leaf preemption-pending-resolution { | | leaf preemption-pending-resolution { |
| type Mpls-te-soft-preemption-resolution; | | type Mpls-te-soft-preemption-resolution; |
| description | | description |
| "Indicates how the soft preemption operation | | "Indicates how the soft preemption operation |
| ended"; | | ended"; |
| } | | } |
| list soft-preemption-path-error { | | list soft-preemption-path-error { |
| description | | description |
| "The array of soft preemption path errors info | | "The array of soft preemption path errors info |
| received for the LSP that is being soft | | received for the LSP that is being soft |
| preempted"; | | preempted"; |
| uses MPLS-TE-SOFT-PREEMPTION-PATH-ERROR; | | uses MPLS-TE-SOFT-PREEMPTION-PATH-ERROR; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-PCE-DELEGATION-INFO { | | grouping MPLS-TE-PCE-DELEGATION-INFO { |
| description | | description |
| "MPLS TE PCE Delegation Information"; | | "MPLS TE PCE Delegation Information"; |
| leaf plsp-id { | | leaf plsp-id { |
| type uint32; | | type uint32; |
| description | | description |
| "PLSP ID"; | | "PLSP ID"; |
| } | | } |
| leaf symbolic-name { | | leaf symbolic-name { |
| type string; | | type string; |
| description | | description |
| "Symbolic name"; | | "Symbolic name"; |
| } | | } |
| leaf owner-address { | | leaf owner-address { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Address of owner node"; | | "Address of owner node"; |
| } | | } |
| leaf operationally-up { | | leaf operationally-up { |
| type boolean; | | type boolean; |
| description | | description |
| "Operationally up"; | | "Operationally up"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-AUTOPCC-INFO { | | grouping MPLS-TE-AUTOPCC-INFO { |
| description | | description |
| "MPLS TE Auto-PCC Information"; | | "MPLS TE Auto-PCC Information"; |
| leaf owner-address { | | leaf owner-address { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Address of owner node"; | | "Address of owner node"; |
| } | | } |
| leaf creator-address { | | leaf creator-address { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Address of creating node"; | | "Address of creating node"; |
| } | | } |
| leaf has-creator-id { | | leaf has-creator-id { |
| type boolean; | | type boolean; |
| description | | description |
| "Indicates if the ID of the creating node is set"; | | "Indicates if the ID of the creating node is set"; |
| } | | } |
| leaf creator-id { | | leaf creator-id { |
| type string; | | type string; |
| description | | description |
| "ID of creating node"; | | "ID of creating node"; |
| } | | } |
| leaf plspid { | | leaf plspid { |
| type uint32; | | type uint32; |
| description | | description |
| "PLSP ID"; | | "PLSP ID"; |
| } | | } |
| leaf symbolic-name { | | leaf symbolic-name { |
| type string; | | type string; |
| description | | description |
| "Symbolic name"; | | "Symbolic name"; |
| } | | } |
| leaf operationally-up { | | leaf operationally-up { |
| type boolean; | | type boolean; |
| description | | description |
| "Operationally up"; | | "Operationally up"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-AUTOMESH-INFO { | | grouping MPLS-TE-AUTOMESH-INFO { |
| description | | description |
| "MPLS TE Automesh Information"; | | "MPLS TE Automesh Information"; |
| leaf mesh-group-id { | | leaf mesh-group-id { |
| type uint32; | | type uint32; |
| description | | description |
| "Auto-mesh tunnel Mesh Group ID"; | | "Auto-mesh tunnel Mesh Group ID"; |
| } | | } |
| leaf tunnel-destination-list-name { | | leaf tunnel-destination-list-name { |
| type string; | | type string; |
| description | | description |
| "Destination List name"; | | "Destination List name"; |
| } | | } |
| leaf is-tunnel-unused-timer-running { | | leaf is-tunnel-unused-timer-running { |
| type boolean; | | type boolean; |
| description | | description |
| "Flag to indicate whether unused timer running"; | | "Flag to indicate whether unused timer running"; |
| } | | } |
| leaf remaining-unused-time { | | leaf remaining-unused-time { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Remaining time for unused timer in seconds"; | | "Remaining time for unused timer in seconds"; |
| } | | } |
| leaf mesh-group-type { | | leaf mesh-group-type { |
| type Te-meshgroup; | | type Te-meshgroup; |
| description | | description |
| "Auto-tunnel mesh group type"; | | "Auto-tunnel mesh group type"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-IEP-HOP-BAG { | | grouping MPLS-TE-IEP-HOP-BAG { |
| description | | description |
| "MPLS IEP Hop information"; | | "MPLS IEP Hop information"; |
| leaf hop-index { | | leaf hop-index { |
| type uint32; | | type uint32; |
| description | | description |
| "Hop Index"; | | "Hop Index"; |
| } | | } |
| leaf iep-hop-type { | | leaf iep-hop-type { |
| type Mpls-te-iep-hop; | | type Mpls-te-iep-hop; |
| description | | description |
| "IEP type"; | | "IEP type"; |
| } | | } |
| leaf iep-hop-address { | | leaf iep-hop-address { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "IEP Hop Address"; | | "IEP Hop Address"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-IEP-BAG { | | grouping MPLS-TE-IEP-BAG { |
| description | | description |
| "MPLS TE IEP"; | | "MPLS TE IEP"; |
| leaf path-option-id { | | leaf path-option-id { |
| type uint32; | | type uint32; |
| description | | description |
| "Path option ID this IEP is associated with"; | | "Path option ID this IEP is associated with"; |
| } | | } |
| list iep-hop { | | list iep-hop { |
| description | | description |
| "IEP Hop List"; | | "IEP Hop List"; |
| uses MPLS-TE-IEP-HOP-BAG; | | uses MPLS-TE-IEP-HOP-BAG; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-WSRLG-HOP-BAG { | | grouping MPLS-TE-WSRLG-HOP-BAG { |
| description | | description |
| "Weighted SRLG info for a hop of the autobackup | | "Weighted SRLG info for a hop of the autobackup |
| tunnel"; | | tunnel"; |
| leaf from-address { | | leaf from-address { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Local IP address"; | | "Local IP address"; |
| } | | } |
| leaf to-address { | | leaf to-address { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Remote IP address"; | | "Remote IP address"; |
| } | | } |
| leaf aggregate-admin-weight { | | leaf aggregate-admin-weight { |
| type uint64; | | type uint64; |
| description | | description |
| "Sum of the admin weights for all the common SRLG | | "Sum of the admin weights for all the common SRLG |
| values"; | | values"; |
| } | | } |
| list common-srlg { | | list common-srlg { |
| description | | description |
| "Common SRLG between this hop and the protected | | "Common SRLG between this hop and the protected |
| | | |
| interface"; | | interface"; |
| leaf entry { | | leaf entry { |
| type uint32; | | type uint32; |
| description | | description |
| "Common SRLG between this hop and the protected | | "Common SRLG between this hop and the protected |
| | | |
| interface"; | | interface"; |
| } | | } |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-WSRLG-VALUE-BAG { | | grouping MPLS-TE-WSRLG-VALUE-BAG { |
| description | | description |
| "MPLS TE weighted SRLGs"; | | "MPLS TE weighted SRLGs"; |
| leaf srlg { | | leaf srlg { |
| type uint32; | | type uint32; |
| description | | description |
| "SRLG number"; | | "SRLG number"; |
| } | | } |
| leaf srlg-name { | | leaf srlg-name { |
| type string; | | type string; |
| description | | description |
| "SRLG name"; | | "SRLG name"; |
| } | | } |
| leaf admin-weight { | | leaf admin-weight { |
| type uint32; | | type uint32; |
| description | | description |
| "Admin weight"; | | "Admin weight"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-WSRLG-INFO-BAG { | | grouping MPLS-TE-WSRLG-INFO-BAG { |
| description | | description |
| "MPLS TE weighted SRLG information for the | | "MPLS TE weighted SRLG information for the |
| autobackup tunnels"; | | autobackup tunnels"; |
| list protected-interface-srlg { | | list protected-interface-srlg { |
| description | | description |
| "SRLG values and admin weight penalties of the | | "SRLG values and admin weight penalties of the |
| protected interface"; | | protected interface"; |
| uses MPLS-TE-WSRLG-VALUE-BAG; | | uses MPLS-TE-WSRLG-VALUE-BAG; |
| } | | } |
| list weighted-srlg-hop { | | list weighted-srlg-hop { |
| description | | description |
| "Autobackup hops and the common SRLG with the | | "Autobackup hops and the common SRLG with the |
| protected interface"; | | protected interface"; |
| uses MPLS-TE-WSRLG-HOP-BAG; | | uses MPLS-TE-WSRLG-HOP-BAG; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-AUTOBACKUP-INFO { | | grouping MPLS-TE-AUTOBACKUP-INFO { |
| description | | description |
| "MPLS TE Autobackup Information"; | | "MPLS TE Autobackup Information"; |
| container weighted-srlg-info { | | container weighted-srlg-info { |
| description | | description |
| "Weighted SRLG info for the autobackup tunnel"; | | "Weighted SRLG info for the autobackup tunnel"; |
| uses MPLS-TE-WSRLG-INFO-BAG; | | uses MPLS-TE-WSRLG-INFO-BAG; |
| } | | } |
| leaf protected-ls-ps { | | leaf protected-ls-ps { |
| type uint32; | | type uint32; |
| description | | description |
| "Number Of Protected LSPs"; | | "Number Of Protected LSPs"; |
| } | | } |
| leaf protected-s2-ls { | | leaf protected-s2-ls { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of Protected S2Ls"; | | "Number of Protected S2Ls"; |
| } | | } |
| leaf sharing-families { | | leaf sharing-families { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of S2L Sharing Families"; | | "Number of S2L Sharing Families"; |
| } | | } |
| leaf ab-protection-type { | | leaf ab-protection-type { |
| type Auto-backup-protection; | | type Auto-backup-protection; |
| description | | description |
| "Protection type"; | | "Protection type"; |
| } | | } |
| leaf is-using-srlg { | | leaf is-using-srlg { |
| type boolean; | | type boolean; |
| description | | description |
| "Indicates whether SRLG Path Option is in use"; | | "Indicates whether SRLG Path Option is in use"; |
| } | | } |
| leaf srlg-prot-type { | | leaf srlg-prot-type { |
| type Auto-backup-srlg-mode; | | type Auto-backup-srlg-mode; |
| description | | description |
| "SRLG Protection Type"; | | "SRLG Protection Type"; |
| } | | } |
| leaf ab-protected-interface { | | leaf ab-protected-interface { |
| type string; | | type string; |
| description | | description |
| "Protected Interface"; | | "Protected Interface"; |
| } | | } |
| leaf protected-address { | | leaf protected-address { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Protected Address"; | | "Protected Address"; |
| } | | } |
| leaf tunnel-attribute-set-name { | | leaf tunnel-attribute-set-name { |
| type string; | | type string; |
| description | | description |
| "AttributeSet name"; | | "AttributeSet name"; |
| } | | } |
| leaf is-unused-removal-timer-running { | | leaf is-unused-removal-timer-running { |
| type boolean; | | type boolean; |
| description | | description |
| "Indicates if the unused removal timer is running"; | | "Indicates if the unused removal timer is running"; |
| } | | } |
| leaf unused-removal-remaining-time { | | leaf unused-removal-remaining-time { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Time Remaining in Unused Removal Time in seconds"; | | "Time Remaining in Unused Removal Time in seconds"; |
| } | | } |
| list iep { | | list iep { |
| description | | description |
| "List of IEPs for the path options on this tunnel"; | | "List of IEPs for the path options on this tunnel"; |
| uses MPLS-TE-IEP-BAG; | | uses MPLS-TE-IEP-BAG; |
| } | | } |
| } | | } |
| | | |
| grouping TE-PP-SW-LOG-ENTRY-BAG { | | grouping TE-PP-SW-LOG-ENTRY-BAG { |
| description | | description |
| "Path protection log entry"; | | "Path protection log entry"; |
| leaf path-protection-switchover-event-index { | | leaf path-protection-switchover-event-index { |
| type uint32; | | type uint32; |
| description | | description |
| "The index number of the path protection switch | | "The index number of the path protection switch |
| over event"; | | over event"; |
| } | | } |
| leaf path-protection-tunnel-id { | | leaf path-protection-tunnel-id { |
| type uint16; | | type uint16; |
| description | | description |
| "The ID of the tunnel that experienced switchover"; | | "The ID of the tunnel that experienced switchover"; |
| } | | } |
| leaf from-lsp-id { | | leaf from-lsp-id { |
| type uint16; | | type uint16; |
| description | | description |
| "The LSP ID from which the traffic was switched | | "The LSP ID from which the traffic was switched |
| over"; | | over"; |
| } | | } |
| leaf to-lsp-id { | | leaf to-lsp-id { |
| type uint16; | | type uint16; |
| description | | description |
| "The LSP ID to which the traffic was switched | | "The LSP ID to which the traffic was switched |
| over"; | | over"; |
| } | | } |
| leaf date-of-error-detection { | | leaf date-of-error-detection { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "The date when the error that caused the | | "The date when the error that caused the |
| switchover was detected. This date is the number | | switchover was detected. This date is the number |
| of seconds since Jan 1st 1970"; | | of seconds since Jan 1st 1970"; |
| } | | } |
| leaf date-of-error-detection-millisec { | | leaf date-of-error-detection-millisec { |
| type uint32; | | type uint32; |
| units "millisecond"; | | units "millisecond"; |
| description | | description |
| "The milliseconds offset of the date when the | | "The milliseconds offset of the date when the |
| error that caused the switchover was detected."; | | error that caused the switchover was detected."; |
| } | | } |
| leaf switchover-duration-millisec { | | leaf switchover-duration-millisec { |
| type uint32; | | type uint32; |
| units "millisecond"; | | units "millisecond"; |
| description | | description |
| "The time in milliseconds between the detection | | "The time in milliseconds between the detection |
| of the error and switching the traffic"; | | of the error and switching the traffic"; |
| } | | } |
| leaf path-protection-switchover-reason { | | leaf path-protection-switchover-reason { |
| type Te-p2mp-s2l-deletion-subcause; | | type Te-p2mp-s2l-deletion-subcause; |
| description | | description |
| "The reason that caused the path protection | | "The reason that caused the path protection |
| switchover"; | | switchover"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-PP-INFO { | | grouping MPLS-TE-PP-INFO { |
| description | | description |
| "MPLS TE Path Protected Switchover Information"; | | "MPLS TE Path Protected Switchover Information"; |
| container switchover { | | container switchover { |
| description | | description |
| "Path Protected Switchover Information"; | | "Path Protected Switchover Information"; |
| uses TE-PP-SW-LOG-ENTRY-BAG; | | uses TE-PP-SW-LOG-ENTRY-BAG; |
| } | | } |
| leaf time-of-switchover-sec { | | leaf time-of-switchover-sec { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "The date when the switchover was completed. This | | "The date when the switchover was completed. This |
| date is the number of seconds since Jan 1st 1970"; | | date is the number of seconds since Jan 1st 1970"; |
| } | | } |
| leaf switchover-total { | | leaf switchover-total { |
| type uint16; | | type uint16; |
| description | | description |
| "Number of times switchover occurred"; | | "Number of times switchover occurred"; |
| } | | } |
| leaf switchover-ready { | | leaf switchover-ready { |
| type uint16; | | type uint16; |
| description | | description |
| "Total times, Standby LSP ready for use"; | | "Total times, Standby LSP ready for use"; |
| } | | } |
| leaf standby-reoptimized-number { | | leaf standby-reoptimized-number { |
| type uint16; | | type uint16; |
| description | | description |
| "Number of times the standby LSP was reoptimized"; | | "Number of times the standby LSP was reoptimized"; |
| } | | } |
| leaf switchover-reason { | | leaf switchover-reason { |
| type uint16; | | type uint16; |
| description | | description |
| "Reason for last switchover"; | | "Reason for last switchover"; |
| } | | } |
| leaf diversity-type { | | leaf diversity-type { |
| type Te-pp-diversity; | | type Te-pp-diversity; |
| description | | description |
| "Standby path diversity type"; | | "Standby path diversity type"; |
| } | | } |
| leaf is-path-protect-configured { | | leaf is-path-protect-configured { |
| type boolean; | | type boolean; |
| description | | description |
| "Is Path Protection Configured"; | | "Is Path Protection Configured"; |
| } | | } |
| leaf path-protection-protected-by-id { | | leaf path-protection-protected-by-id { |
| type uint32; | | type uint32; |
| description | | description |
| "The path option ID (level/index) of the | | "The path option ID (level/index) of the |
| configured explicit protecting path"; | | configured explicit protecting path"; |
| } | | } |
| leaf valid-path-protection-path-option-exists { | | leaf valid-path-protection-path-option-exists { |
| type boolean; | | type boolean; |
| description | | description |
| "Flag to indicate whether tunnel has a | | "Flag to indicate whether tunnel has a |
| path-option which is valid for path-protection"; | | path-option which is valid for path-protection"; |
| } | | } |
| leaf is-path-protect-switch-over-underway { | | leaf is-path-protect-switch-over-underway { |
| type boolean; | | type boolean; |
| description | | description |
| "Is Switchover Underway"; | | "Is Switchover Underway"; |
| } | | } |
| leaf reoptimization-time-remaining { | | leaf reoptimization-time-remaining { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Remaining time until path protection | | "Remaining time until path protection |
| reoptimization (seconds)"; | | reoptimization (seconds)"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-TUNNELS-TUNNEL-LAST-REOPT-FAIL-INFO { | | grouping MPLS-TE-TUNNELS-TUNNEL-LAST-REOPT-FAIL-INFO { |
| description | | description |
| "Last re-opt failure reason/information if | | "Last re-opt failure reason/information if |
| applicable"; | | applicable"; |
| leaf re-opt-last-fail-reason { | | leaf re-opt-last-fail-reason { |
| type Mpls-te-reopt-decision-reason; | | type Mpls-te-reopt-decision-reason; |
| description | | description |
| "Reason (if any) for the last re-opt attempt | | "Reason (if any) for the last re-opt attempt |
| failure"; | | failure"; |
| } | | } |
| leaf re-opt-failed-destination { | | leaf re-opt-failed-destination { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "First tunnel destination (if any) in re-opt LSP | | "First tunnel destination (if any) in re-opt LSP |
| that failed to come up"; | | that failed to come up"; |
| } | | } |
| leaf re-opt-failed-timestamp { | | leaf re-opt-failed-timestamp { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Time stamp of the last re-opt failure. (seconds | | "Time stamp of the last re-opt failure. (seconds |
| since Jan. 1, 1970)"; | | since Jan. 1, 1970)"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-TUNNELS-HISTORY-STANDBY-SETUP { | | grouping MPLS-TE-TUNNELS-HISTORY-STANDBY-SETUP { |
| description | | description |
| "History information for standby setup"; | | "History information for standby setup"; |
| leaf standby-lsp-uptime { | | leaf standby-lsp-uptime { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Time in seconds since the standby LSP was up"; | | "Time in seconds since the standby LSP was up"; |
| } | | } |
| leaf standby-setup-timer { | | leaf standby-setup-timer { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Time in seconds until the next attempt to | | "Time in seconds until the next attempt to |
| connect this setup"; | | connect this setup"; |
| } | | } |
| leaf protection-role { | | leaf protection-role { |
| type Te-lsp-path-protection-role; | | type Te-lsp-path-protection-role; |
| description | | description |
| "Path Protection Role"; | | "Path Protection Role"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-TUNNELS-HISTORY-OTHER-SETUP { | | grouping MPLS-TE-TUNNELS-HISTORY-OTHER-SETUP { |
| description | | description |
| "History information for additional GMPLS setup"; | | "History information for additional GMPLS setup"; |
| leaf path-option-index { | | leaf path-option-index { |
| type uint32; | | type uint32; |
| description | | description |
| "Path option index for the additional setup"; | | "Path option index for the additional setup"; |
| } | | } |
| leaf other-setup-error { | | leaf other-setup-error { |
| type string; | | type string; |
| description | | description |
| "The last error for the additional setup"; | | "The last error for the additional setup"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-TUNNELS-HISTORY-PREVIOUS-PROTECT { | | grouping MPLS-TE-TUNNELS-HISTORY-PREVIOUS-PROTECT { |
| description | | description |
| "History information for previous protecting GMPLS | | "History information for previous protecting GMPLS |
| current setup"; | | current setup"; |
| leaf previous-protect-path-option { | | leaf previous-protect-path-option { |
| type string; | | type string; |
| description | | description |
| "The previous protect setup path option"; | | "The previous protect setup path option"; |
| } | | } |
| leaf previous-protect-tunnel-instance { | | leaf previous-protect-tunnel-instance { |
| type uint32; | | type uint32; |
| description | | description |
| "The previous protect setup's instance"; | | "The previous protect setup's instance"; |
| } | | } |
| leaf previous-protect-fail-reason { | | leaf previous-protect-fail-reason { |
| type string; | | type string; |
| description | | description |
| "Reason for the previous protect setup's failure"; | | "Reason for the previous protect setup's failure"; |
| } | | } |
| leaf previous-protect-setup-last-error { | | leaf previous-protect-setup-last-error { |
| type string; | | type string; |
| description | | description |
| "The last error for the previous setup"; | | "The last error for the previous setup"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-TUNNELS-HISTORY-PREVIOUS { | | grouping MPLS-TE-TUNNELS-HISTORY-PREVIOUS { |
| description | | description |
| "History information for previous current setup"; | | "History information for previous current setup"; |
| leaf previous-path-option { | | leaf previous-path-option { |
| type string; | | type string; |
| description | | description |
| "The previous setup path option"; | | "The previous setup path option"; |
| } | | } |
| leaf previous-tunnel-instance { | | leaf previous-tunnel-instance { |
| type uint32; | | type uint32; |
| description | | description |
| "The previous setup's instance"; | | "The previous setup's instance"; |
| } | | } |
| leaf previous-fail-reason { | | leaf previous-fail-reason { |
| type string; | | type string; |
| description | | description |
| "Reason for the previous setup's failure"; | | "Reason for the previous setup's failure"; |
| } | | } |
| leaf previous-setup-last-error { | | leaf previous-setup-last-error { |
| type string; | | type string; |
| description | | description |
| "The last error for the previous setup"; | | "The last error for the previous setup"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-TUNNELS-HISTORY-PATH-PROTECT { | | grouping MPLS-TE-TUNNELS-HISTORY-PATH-PROTECT { |
| description | | description |
| "History information for protecting setup"; | | "History information for protecting setup"; |
| leaf protecting-setup-uptime { | | leaf protecting-setup-uptime { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Time in seconds since the protecting setup came | | "Time in seconds since the protecting setup came |
| up"; | | up"; |
| } | | } |
| leaf protecting-setup-timer { | | leaf protecting-setup-timer { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Time in seconds until the next attempt to | | "Time in seconds until the next attempt to |
| connect the protecting setup"; | | connect the protecting setup"; |
| } | | } |
| leaf protecting-setup-last-error { | | leaf protecting-setup-last-error { |
| type string; | | type string; |
| description | | description |
| "The last error for the protecting setup (for | | "The last error for the protecting setup (for |
| display purposes only)"; | | display purposes only)"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-TUNNELS-HISTORY-REOPT { | | grouping MPLS-TE-TUNNELS-HISTORY-REOPT { |
| description | | description |
| "History information for reoptimized setup"; | | "History information for reoptimized setup"; |
| leaf reoptimized-setup-uptime { | | leaf reoptimized-setup-uptime { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Time in seconds since the reopt setup came up"; | | "Time in seconds since the reopt setup came up"; |
| } | | } |
| leaf reoptimized-setup-timer { | | leaf reoptimized-setup-timer { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Time in seconds until the next attempt to | | "Time in seconds until the next attempt to |
| connect the reopt setup"; | | connect the reopt setup"; |
| } | | } |
| leaf reoptimized-setup-last-error { | | leaf reoptimized-setup-last-error { |
| type string; | | type string; |
| description | | description |
| "The last error for the reopt setup"; | | "The last error for the reopt setup"; |
| } | | } |
| leaf protection-role { | | leaf protection-role { |
| type Te-lsp-path-protection-role; | | type Te-lsp-path-protection-role; |
| description | | description |
| "Path Protection Role"; | | "Path Protection Role"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-TUNNELS-HISTORY-CURRENT-CONNECTED { | | grouping MPLS-TE-TUNNELS-HISTORY-CURRENT-CONNECTED { |
| description | | description |
| "History information for currently connected setup"; | | "History information for currently connected setup"; |
| leaf current-lsp-uptime { | | leaf current-lsp-uptime { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Time in seconds since the current LSP was up"; | | "Time in seconds since the current LSP was up"; |
| } | | } |
| leaf current-uptime { | | leaf current-uptime { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Time in seconds since the tunnel was up"; | | "Time in seconds since the tunnel was up"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-TUNNELS-HISTORY-CURRENT { | | grouping MPLS-TE-TUNNELS-HISTORY-CURRENT { |
| description | | description |
| "History information for current setup"; | | "History information for current setup"; |
| container connected-uptimes { | | container connected-uptimes { |
| description | | description |
| "Uptimes for connected setup"; | | "Uptimes for connected setup"; |
| uses MPLS-TE-TUNNELS-HISTORY-CURRENT-CONNECTED; | | uses MPLS-TE-TUNNELS-HISTORY-CURRENT-CONNECTED; |
| } | | } |
| leaf current-setup-timer { | | leaf current-setup-timer { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Time in seconds until the next attempt to | | "Time in seconds until the next attempt to |
| connect this setup"; | | connect this setup"; |
| } | | } |
| leaf selection-reason { | | leaf selection-reason { |
| type string; | | type string; |
| description | | description |
| "The reason why this setup is selected. For | | "The reason why this setup is selected. For |
| display purposes only."; | | display purposes only."; |
| } | | } |
| leaf current-setup-last-error { | | leaf current-setup-last-error { |
| type string; | | type string; |
| description | | description |
| "The last error for the current setup"; | | "The last error for the current setup"; |
| } | | } |
| leaf protection-role { | | leaf protection-role { |
| type Te-lsp-path-protection-role; | | type Te-lsp-path-protection-role; |
| description | | description |
| "Path Protection Role"; | | "Path Protection Role"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-TUNNELS-HISTORY-BAG { | | grouping MPLS-TE-TUNNELS-HISTORY-BAG { |
| description | | description |
| "MPLS TE Tunnel History Information"; | | "MPLS TE Tunnel History Information"; |
| container current-setup { | | container current-setup { |
| description | | description |
| "Current setup data"; | | "Current setup data"; |
| uses MPLS-TE-TUNNELS-HISTORY-CURRENT; | | uses MPLS-TE-TUNNELS-HISTORY-CURRENT; |
| } | | } |
| container reopt-setup { | | container reopt-setup { |
| description | | description |
| "Reoptimized setup data"; | | "Reoptimized setup data"; |
| uses MPLS-TE-TUNNELS-HISTORY-REOPT; | | uses MPLS-TE-TUNNELS-HISTORY-REOPT; |
| } | | } |
| container gmpls-path-protect-setup { | | container gmpls-path-protect-setup { |
| description | | description |
| "GMPLS protecting setup data"; | | "GMPLS protecting setup data"; |
| uses MPLS-TE-TUNNELS-HISTORY-PATH-PROTECT; | | uses MPLS-TE-TUNNELS-HISTORY-PATH-PROTECT; |
| } | | } |
| container previous-setup { | | container previous-setup { |
| description | | description |
| "Previous setup data"; | | "Previous setup data"; |
| uses MPLS-TE-TUNNELS-HISTORY-PREVIOUS; | | uses MPLS-TE-TUNNELS-HISTORY-PREVIOUS; |
| } | | } |
| container previous-gmpls-path-protect-setup { | | container previous-gmpls-path-protect-setup { |
| description | | description |
| "Previous GMPLS protecting setup data"; | | "Previous GMPLS protecting setup data"; |
| uses MPLS-TE-TUNNELS-HISTORY-PREVIOUS-PROTECT; | | uses MPLS-TE-TUNNELS-HISTORY-PREVIOUS-PROTECT; |
| } | | } |
| container gmpls-other-setup { | | container gmpls-other-setup { |
| description | | description |
| "GMPLS additional setup data"; | | "GMPLS additional setup data"; |
| uses MPLS-TE-TUNNELS-HISTORY-OTHER-SETUP; | | uses MPLS-TE-TUNNELS-HISTORY-OTHER-SETUP; |
| } | | } |
| container gmpls-other-protect-setup { | | container gmpls-other-protect-setup { |
| description | | description |
| "GMPLS additional protecting setup data"; | | "GMPLS additional protecting setup data"; |
| uses MPLS-TE-TUNNELS-HISTORY-OTHER-SETUP; | | uses MPLS-TE-TUNNELS-HISTORY-OTHER-SETUP; |
| } | | } |
| container standby-setup { | | container standby-setup { |
| description | | description |
| "Standby setup data"; | | "Standby setup data"; |
| uses MPLS-TE-TUNNELS-HISTORY-STANDBY-SETUP; | | uses MPLS-TE-TUNNELS-HISTORY-STANDBY-SETUP; |
| } | | } |
| container standby-reopt-setup { | | container standby-reopt-setup { |
| description | | description |
| "Standby Reopt setup data"; | | "Standby Reopt setup data"; |
| uses MPLS-TE-TUNNELS-HISTORY-REOPT; | | uses MPLS-TE-TUNNELS-HISTORY-REOPT; |
| } | | } |
| container last-re-opt-fail { | | container last-re-opt-fail { |
| description | | description |
| "Last re-opt attempt failure information"; | | "Last re-opt attempt failure information"; |
| uses MPLS-TE-TUNNELS-TUNNEL-LAST-REOPT-FAIL-INFO; | | uses MPLS-TE-TUNNELS-TUNNEL-LAST-REOPT-FAIL-INFO; |
| } | | } |
| container last-stdby-re-opt-fail { | | container last-stdby-re-opt-fail { |
| description | | description |
| "Last standby re-opt attempt failure information"; | | "Last standby re-opt attempt failure information"; |
| uses MPLS-TE-TUNNELS-TUNNEL-LAST-REOPT-FAIL-INFO; | | uses MPLS-TE-TUNNELS-TUNNEL-LAST-REOPT-FAIL-INFO; |
| } | | } |
| } | | } |
| | | |
| n | grouping MPLS-TE-SELF-PING { | n | |
| description | | |
| "Self-ping information for TE tunnels"; | | |
| leaf state { | | |
| type Self-ping-state; | | |
| description | | |
| "The state of the self-ping operation"; | | |
| } | | |
| leaf lsp-id { | | |
| type uint16; | | |
| description | | |
| "The ID of the LSP for which self-ping is done"; | | |
| } | | |
| leaf start-timestamp { | | |
| type uint32; | | |
| description | | |
| "The timestamp when the self-ping was initiated | | |
| relative to Jan 1, 1970"; | | |
| } | | |
| leaf stop-timestamp { | | |
| type uint32; | | |
| description | | |
| "The timestamp when the self-ping was stopped | | |
| relative to Jan 1, 1970"; | | |
| } | | |
| leaf probe-received-timestamp { | | |
| type uint32; | | |
| description | | |
| "The timestamp when the self-ping response was | | |
| received relative to Jan 1, 1970"; | | |
| } | | |
| leaf probes-sent { | | |
| type uint16; | | |
| description | | |
| "The number of self-ping probes sent"; | | |
| } | | |
| } | | |
| | | |
| grouping MPLS-TE-AUTOCAPACITY-CLONE { | | grouping MPLS-TE-AUTOCAPACITY-CLONE { |
| description | | description |
| "Brief information about a clone tunnel"; | | "Brief information about a clone tunnel"; |
| leaf name { | | leaf name { |
| type string; | | type string; |
| description | | description |
| "Name of the clone"; | | "Name of the clone"; |
| } | | } |
| leaf creation-timestamp { | | leaf creation-timestamp { |
| type uint32; | | type uint32; |
| description | | description |
| "The timestamp when this clone was created | | "The timestamp when this clone was created |
| relative to Jan 1, 1970"; | | relative to Jan 1, 1970"; |
| } | | } |
| leaf state { | | leaf state { |
| type Mte-tunnel-oper-state; | | type Mte-tunnel-oper-state; |
| description | | description |
| "The interface state of the cloned tunnel"; | | "The interface state of the cloned tunnel"; |
| } | | } |
| leaf signaled-bandwidth { | | leaf signaled-bandwidth { |
| type uint32; | | type uint32; |
| units "kbit/s"; | | units "kbit/s"; |
| description | | description |
| "The signaled bandwidth (kbps) of the clone"; | | "The signaled bandwidth (kbps) of the clone"; |
| } | | } |
| leaf current-bandwidth-demand { | | leaf current-bandwidth-demand { |
| type uint32; | | type uint32; |
| units "kbit/s"; | | units "kbit/s"; |
| description | | description |
| "The current demand (kbps) read from the traffic | | "The current demand (kbps) read from the traffic |
| stats for the clone"; | | stats for the clone"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-AUTOCAPACITY-STATS { | | grouping MPLS-TE-AUTOCAPACITY-STATS { |
| description | | description |
| "Statistics for auto-capacity"; | | "Statistics for auto-capacity"; |
| leaf splits { | | leaf splits { |
| type uint32; | | type uint32; |
| description | | description |
| "Count of splits events"; | | "Count of splits events"; |
| } | | } |
| leaf merges { | | leaf merges { |
| type uint32; | | type uint32; |
| description | | description |
| "Count of merges events"; | | "Count of merges events"; |
| } | | } |
| leaf total-clones-created { | | leaf total-clones-created { |
| type uint32; | | type uint32; |
| description | | description |
| "Total clones created"; | | "Total clones created"; |
| } | | } |
| leaf total-clones-deleted { | | leaf total-clones-deleted { |
| type uint32; | | type uint32; |
| description | | description |
| "Total clones deleted"; | | "Total clones deleted"; |
| } | | } |
| leaf high-watermark-clones { | | leaf high-watermark-clones { |
| type uint32; | | type uint32; |
| description | | description |
| "Highest number of clones reached at any point in | | "Highest number of clones reached at any point in |
| time"; | | time"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-AUTOCAPACITY-CONFIG { | | grouping MPLS-TE-AUTOCAPACITY-CONFIG { |
| description | | description |
| "Configured properties of auto-capacity"; | | "Configured properties of auto-capacity"; |
| leaf minimum-clones { | | leaf minimum-clones { |
| type uint32; | | type uint32; |
| description | | description |
| "The minimum number of clones"; | | "The minimum number of clones"; |
| } | | } |
| leaf maximum-clones { | | leaf maximum-clones { |
| type uint32; | | type uint32; |
| description | | description |
| "The maximum number of clones"; | | "The maximum number of clones"; |
| } | | } |
| leaf merge-bandwidth { | | leaf merge-bandwidth { |
| type uint32; | | type uint32; |
| units "kbit/s"; | | units "kbit/s"; |
| description | | description |
| "The merge bandwidth in kbps"; | | "The merge bandwidth in kbps"; |
| } | | } |
| leaf split-bandwidth { | | leaf split-bandwidth { |
| type uint32; | | type uint32; |
| units "kbit/s"; | | units "kbit/s"; |
| description | | description |
| "The split bandwidth in kbps"; | | "The split bandwidth in kbps"; |
| } | | } |
| leaf nominal-bandwidth { | | leaf nominal-bandwidth { |
| type uint32; | | type uint32; |
| units "kbit/s"; | | units "kbit/s"; |
| description | | description |
| "The optimal or nominal bandwidth for the clones | | "The optimal or nominal bandwidth for the clones |
| in kbps"; | | in kbps"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-AUTOCAPACITY { | | grouping MPLS-TE-AUTOCAPACITY { |
| description | | description |
| "Auto-capacity information for TE tunnels"; | | "Auto-capacity information for TE tunnels"; |
| container auto-capacity-configuration { | | container auto-capacity-configuration { |
| description | | description |
| "The configured properties of auto-capacity"; | | "The configured properties of auto-capacity"; |
| uses MPLS-TE-AUTOCAPACITY-CONFIG; | | uses MPLS-TE-AUTOCAPACITY-CONFIG; |
| } | | } |
| container auto-capacity-stats { | | container auto-capacity-stats { |
| description | | description |
| "The statistic of auto-capacity"; | | "The statistic of auto-capacity"; |
| uses MPLS-TE-AUTOCAPACITY-STATS; | | uses MPLS-TE-AUTOCAPACITY-STATS; |
| } | | } |
| list clone { | | list clone { |
| description | | description |
| "Table of clones"; | | "Table of clones"; |
| uses MPLS-TE-AUTOCAPACITY-CLONE; | | uses MPLS-TE-AUTOCAPACITY-CLONE; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-TUNNELS-AUTOBW-OPER { | | grouping MPLS-TE-TUNNELS-AUTOBW-OPER { |
| description | | description |
| "MPLS TE Tunnel AutoBandwidth Operational | | "MPLS TE Tunnel AutoBandwidth Operational |
| Information"; | | Information"; |
| leaf last-bandwidth-applied { | | leaf last-bandwidth-applied { |
| type uint32; | | type uint32; |
| description | | description |
| "Last bandwidth requested by auto-bw for the | | "Last bandwidth requested by auto-bw for the |
| tunnel"; | | tunnel"; |
| } | | } |
| leaf bandwidth-pool-type { | | leaf bandwidth-pool-type { |
| type Mpls-te-bw-pool; | | type Mpls-te-bw-pool; |
| description | | description |
| "Bandwidth pool type"; | | "Bandwidth pool type"; |
| } | | } |
| leaf bandwidth-applications { | | leaf bandwidth-applications { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of bandwidth applications requested | | "Total number of bandwidth applications requested |
| by auto-bw"; | | by auto-bw"; |
| } | | } |
| leaf last-application-trigger { | | leaf last-application-trigger { |
| type Te-autobw-app-trigger; | | type Te-autobw-app-trigger; |
| description | | description |
| "The reason causing the last BW application"; | | "The reason causing the last BW application"; |
| } | | } |
| leaf application-jitter { | | leaf application-jitter { |
| type uint32; | | type uint32; |
| description | | description |
| "Amount of time introduced to delay first | | "Amount of time introduced to delay first |
| application so that not all tunnels may signal | | application so that not all tunnels may signal |
| BW at the same time"; | | BW at the same time"; |
| } | | } |
| leaf time-left-application { | | leaf time-left-application { |
| type uint32; | | type uint32; |
| description | | description |
| "Time left until next auto-bw application | | "Time left until next auto-bw application |
| algorithm is performed"; | | algorithm is performed"; |
| } | | } |
| leaf samples-collected { | | leaf samples-collected { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of samples collected within current | | "Number of samples collected within current |
| application period"; | | application period"; |
| } | | } |
| leaf time-left-collection { | | leaf time-left-collection { |
| type uint32; | | type uint32; |
| description | | description |
| "Time left until next auto-bw data collection is | | "Time left until next auto-bw data collection is |
| performed"; | | performed"; |
| } | | } |
| leaf highest-bandwidth { | | leaf highest-bandwidth { |
| type uint32; | | type uint32; |
| description | | description |
| "Highest bandwidth registered within current | | "Highest bandwidth registered within current |
| application period"; | | application period"; |
| } | | } |
| leaf underflow-highest-bandwidth { | | leaf underflow-highest-bandwidth { |
| type uint32; | | type uint32; |
| description | | description |
| "Highest sample collected during an underflow | | "Highest sample collected during an underflow |
| sequence"; | | sequence"; |
| } | | } |
| leaf threshold-overflows { | | leaf threshold-overflows { |
| type uint32; | | type uint32; |
| description | | description |
| "counter for current consecutive collections | | "counter for current consecutive collections |
| exceeding threshold"; | | exceeding threshold"; |
| } | | } |
| leaf overflow-early-bw-applications { | | leaf overflow-early-bw-applications { |
| type uint32; | | type uint32; |
| description | | description |
| "tunnel counter for number of bandwidth | | "tunnel counter for number of bandwidth |
| applications due to overflow"; | | applications due to overflow"; |
| } | | } |
| leaf threshold-underflows { | | leaf threshold-underflows { |
| type uint32; | | type uint32; |
| description | | description |
| "counter for current consecutive collections | | "counter for current consecutive collections |
| exceeding threshold"; | | exceeding threshold"; |
| } | | } |
| leaf underflow-early-bw-applications { | | leaf underflow-early-bw-applications { |
| type uint32; | | type uint32; |
| description | | description |
| "tunnel counter for number of bandwidth | | "tunnel counter for number of bandwidth |
| applications due to underflow"; | | applications due to underflow"; |
| } | | } |
| leaf collect-only-requested-bandwidth { | | leaf collect-only-requested-bandwidth { |
| type uint32; | | type uint32; |
| description | | description |
| "Collect-only Requested Bandwidth for the tunnel"; | | "Collect-only Requested Bandwidth for the tunnel"; |
| } | | } |
| leaf application-reject-reason { | | leaf application-reject-reason { |
| type Te-autobw-app-rej; | | type Te-autobw-app-rej; |
| description | | description |
| "Current application reject reason"; | | "Current application reject reason"; |
| } | | } |
| leaf resignal-last-bandwidth-expire-time { | | leaf resignal-last-bandwidth-expire-time { |
| type uint32; | | type uint32; |
| description | | description |
| "Timestamp when the resignal last bandwidth will | | "Timestamp when the resignal last bandwidth will |
| expire and tunnel will use configured bandwidth | | expire and tunnel will use configured bandwidth |
| to setup"; | | to setup"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-TUNNELS-AUTOBW-CONFIG { | | grouping MPLS-TE-TUNNELS-AUTOBW-CONFIG { |
| description | | description |
| "MPLS TE Tunnel AutoBandwidth Configuration | | "MPLS TE Tunnel AutoBandwidth Configuration |
| Information"; | | Information"; |
| leaf is-auto-bandwidth-collect-only { | | leaf is-auto-bandwidth-collect-only { |
| type boolean; | | type boolean; |
| description | | description |
| "TRUE if auto-bw collection-only is enabled"; | | "TRUE if auto-bw collection-only is enabled"; |
| } | | } |
| leaf minimum-bandwidth { | | leaf minimum-bandwidth { |
| type uint32; | | type uint32; |
| description | | description |
| "Minimum bandwidth auto-bw can apply"; | | "Minimum bandwidth auto-bw can apply"; |
| } | | } |
| leaf maximum-bandwidth { | | leaf maximum-bandwidth { |
| type uint32; | | type uint32; |
| description | | description |
| "Maximum bandwidth auto-bw can apply"; | | "Maximum bandwidth auto-bw can apply"; |
| } | | } |
| leaf application-frequency { | | leaf application-frequency { |
| type uint32; | | type uint32; |
| units "minute"; | | units "minute"; |
| description | | description |
| "Auto-bw application frequency for the tunnel | | "Auto-bw application frequency for the tunnel |
| (mins)"; | | (mins)"; |
| } | | } |
| leaf collection-frequency { | | leaf collection-frequency { |
| type uint32; | | type uint32; |
| description | | description |
| "Global auto-bw collection frequency"; | | "Global auto-bw collection frequency"; |
| } | | } |
| leaf adjustment-threshold-percent { | | leaf adjustment-threshold-percent { |
| type uint32; | | type uint32; |
| description | | description |
| "Bandwidth change threshold needed to trigger | | "Bandwidth change threshold needed to trigger |
| bandwidth adjustment"; | | bandwidth adjustment"; |
| } | | } |
| leaf adjustment-threshold-value { | | leaf adjustment-threshold-value { |
| type uint32; | | type uint32; |
| units "kbit/s"; | | units "kbit/s"; |
| description | | description |
| "Bandwidth change value (kbps) needed to trigger | | "Bandwidth change value (kbps) needed to trigger |
| bandwidth adjustment"; | | bandwidth adjustment"; |
| } | | } |
| leaf overflow-threshold-percent { | | leaf overflow-threshold-percent { |
| type uint32; | | type uint32; |
| description | | description |
| "Bandwidth change threshold needed to count a | | "Bandwidth change threshold needed to count a |
| collection towards overflow limit allowed"; | | collection towards overflow limit allowed"; |
| } | | } |
| leaf overflow-threshold-value { | | leaf overflow-threshold-value { |
| type uint32; | | type uint32; |
| description | | description |
| "Bandwidth change value needed to count a | | "Bandwidth change value needed to count a |
| collection towards overflow limit allowed"; | | collection towards overflow limit allowed"; |
| } | | } |
| leaf overflow-threshold-limit { | | leaf overflow-threshold-limit { |
| type uint32; | | type uint32; |
| description | | description |
| "Limit of consecutive collections exceeding | | "Limit of consecutive collections exceeding |
| threshold to trigger an immediate overflow | | threshold to trigger an immediate overflow |
| bandwidth adjustment"; | | bandwidth adjustment"; |
| } | | } |
| leaf underflow-threshold-percent { | | leaf underflow-threshold-percent { |
| type uint32; | | type uint32; |
| description | | description |
| "Bandwidth change threshold needed to count a | | "Bandwidth change threshold needed to count a |
| collection towards underflow limit allowed"; | | collection towards underflow limit allowed"; |
| } | | } |
| leaf underflow-threshold-value { | | leaf underflow-threshold-value { |
| type uint32; | | type uint32; |
| description | | description |
| "Bandwidth change value needed to count a | | "Bandwidth change value needed to count a |
| collection towards underflow limit allowed"; | | collection towards underflow limit allowed"; |
| } | | } |
| leaf underflow-threshold-limit { | | leaf underflow-threshold-limit { |
| type uint32; | | type uint32; |
| description | | description |
| "Limit of consecutive collections exceeding | | "Limit of consecutive collections exceeding |
| threshold to trigger an immediate underflow | | threshold to trigger an immediate underflow |
| bandwidth adjustment"; | | bandwidth adjustment"; |
| } | | } |
| leaf resignal-last-bandwidth-enabled { | | leaf resignal-last-bandwidth-enabled { |
| type boolean; | | type boolean; |
| description | | description |
| "TRUE if resignal last bandwidth is enabled"; | | "TRUE if resignal last bandwidth is enabled"; |
| } | | } |
| leaf resignal-last-bandwidth-timeout { | | leaf resignal-last-bandwidth-timeout { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "The configured time-out value in seconds for | | "The configured time-out value in seconds for |
| resignal last bandwidth after tunnel down"; | | resignal last bandwidth after tunnel down"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-TUNNELS-AUTOBW-STATUS { | | grouping MPLS-TE-TUNNELS-AUTOBW-STATUS { |
| description | | description |
| "MPLS TE Tunnel AutoBandwidth Status Information"; | | "MPLS TE Tunnel AutoBandwidth Status Information"; |
| leaf is-auto-bandwidth-enabled { | | leaf is-auto-bandwidth-enabled { |
| type boolean; | | type boolean; |
| description | | description |
| "TRUE if auto-bw is enabled for the tunnel"; | | "TRUE if auto-bw is enabled for the tunnel"; |
| } | | } |
| leaf reactivation-time { | | leaf reactivation-time { |
| type uint32; | | type uint32; |
| description | | description |
| "Time until auto-bw gets activated if activation | | "Time until auto-bw gets activated if activation |
| has been delayed due to failover"; | | has been delayed due to failover"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-P2P-INFO-BAG { | | grouping MPLS-TE-P2P-INFO-BAG { |
| description | | description |
| "P2P tunnel data"; | | "P2P tunnel data"; |
| container auto-bandwidth-status { | | container auto-bandwidth-status { |
| description | | description |
| "Tunnels's AutoBandwidth Status information"; | | "Tunnels's AutoBandwidth Status information"; |
| uses MPLS-TE-TUNNELS-AUTOBW-STATUS; | | uses MPLS-TE-TUNNELS-AUTOBW-STATUS; |
| } | | } |
| container auto-bandwidth-config { | | container auto-bandwidth-config { |
| description | | description |
| "Tunnels's AutoBandwidth Configuration | | "Tunnels's AutoBandwidth Configuration |
| information"; | | information"; |
| uses MPLS-TE-TUNNELS-AUTOBW-CONFIG; | | uses MPLS-TE-TUNNELS-AUTOBW-CONFIG; |
| } | | } |
| container auto-bandwidth-oper { | | container auto-bandwidth-oper { |
| description | | description |
| "Tunnels's AutoBandwidth Operational information"; | | "Tunnels's AutoBandwidth Operational information"; |
| uses MPLS-TE-TUNNELS-AUTOBW-OPER; | | uses MPLS-TE-TUNNELS-AUTOBW-OPER; |
| } | | } |
| leaf is-bidirectional { | | leaf is-bidirectional { |
| type boolean; | | type boolean; |
| description | | description |
| "TRUE if the tunnel is bidirectional"; | | "TRUE if the tunnel is bidirectional"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-INTERAREA-REOPT-INFO { | | grouping MPLS-TE-INTERAREA-REOPT-INFO { |
| description | | description |
| "Counter and time information for reoptimization | | "Counter and time information for reoptimization |
| of interarea tunnels"; | | of interarea tunnels"; |
| leaf sent-path-queries { | | leaf sent-path-queries { |
| type uint16; | | type uint16; |
| description | | description |
| "Number of better path queries sent"; | | "Number of better path queries sent"; |
| } | | } |
| leaf time-since-last-query-sent { | | leaf time-since-last-query-sent { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Time since the last better path query was sent | | "Time since the last better path query was sent |
| (seconds)"; | | (seconds)"; |
| } | | } |
| leaf received-preferred-path-errors { | | leaf received-preferred-path-errors { |
| type uint16; | | type uint16; |
| description | | description |
| "Number of received Preferred Path Exists Error"; | | "Number of received Preferred Path Exists Error"; |
| } | | } |
| leaf time-since-last-preferred-path-error { | | leaf time-since-last-preferred-path-error { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Time since last Preferred Path Exists error | | "Time since last Preferred Path Exists error |
| received (seconds)"; | | received (seconds)"; |
| } | | } |
| leaf received-preferred-tree-errors { | | leaf received-preferred-tree-errors { |
| type uint16; | | type uint16; |
| description | | description |
| "Number of received Preferred Tree Exists Error"; | | "Number of received Preferred Tree Exists Error"; |
| } | | } |
| leaf time-since-last-preferred-tree-error { | | leaf time-since-last-preferred-tree-error { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Time since last Preferred Tree Exists error | | "Time since last Preferred Tree Exists error |
| received (seconds)"; | | received (seconds)"; |
| } | | } |
| leaf preferred-path-error-node { | | leaf preferred-path-error-node { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Address of the preferred path error generating | | "Address of the preferred path error generating |
| node"; | | node"; |
| } | | } |
| leaf preferred-tree-error-node { | | leaf preferred-tree-error-node { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Address of the preferred tree error generating | | "Address of the preferred tree error generating |
| node"; | | node"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-P2MP-DEST { | | grouping MPLS-TE-P2MP-DEST { |
| description | | description |
| "A P2MP destination"; | | "A P2MP destination"; |
| container inter-area-reoptimization { | | container inter-area-reoptimization { |
| description | | description |
| "The timing and count information of interarea | | "The timing and count information of interarea |
| reoptimization."; | | reoptimization."; |
| uses MPLS-TE-INTERAREA-REOPT-INFO; | | uses MPLS-TE-INTERAREA-REOPT-INFO; |
| } | | } |
| leaf destination-address { | | leaf destination-address { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Destination address"; | | "Destination address"; |
| } | | } |
| leaf destination-state { | | leaf destination-state { |
| type Te-destination-state; | | type Te-destination-state; |
| description | | description |
| "The state of the destination"; | | "The state of the destination"; |
| } | | } |
| leaf active-path-option-index { | | leaf active-path-option-index { |
| type uint32; | | type uint32; |
| description | | description |
| "Index of active path option"; | | "Index of active path option"; |
| } | | } |
| leaf path-option-exhausted { | | leaf path-option-exhausted { |
| type boolean; | | type boolean; |
| description | | description |
| "Path options are exhausted"; | | "Path options are exhausted"; |
| } | | } |
| leaf uptime { | | leaf uptime { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Time in seconds since the destination was up"; | | "Time in seconds since the destination was up"; |
| } | | } |
| leaf path-change-time { | | leaf path-change-time { |
| type uint32; | | type uint32; |
| description | | description |
| "Last path change time"; | | "Last path change time"; |
| } | | } |
| leaf total-uptime { | | leaf total-uptime { |
| type uint32; | | type uint32; |
| description | | description |
| "Unused"; | | "Unused"; |
| } | | } |
| leaf s2l-exist { | | leaf s2l-exist { |
| type boolean; | | type boolean; |
| description | | description |
| "Dest state may not be up but S2L may exist"; | | "Dest state may not be up but S2L may exist"; |
| } | | } |
| leaf destination-deletion-cause { | | leaf destination-deletion-cause { |
| type Te-p2mp-s2l-deletion-cause; | | type Te-p2mp-s2l-deletion-cause; |
| description | | description |
| "Destination deletion cause"; | | "Destination deletion cause"; |
| } | | } |
| leaf destination-deletion-sub-cause { | | leaf destination-deletion-sub-cause { |
| type Te-p2mp-s2l-deletion-subcause; | | type Te-p2mp-s2l-deletion-subcause; |
| description | | description |
| "Destination deletion subcause"; | | "Destination deletion subcause"; |
| } | | } |
| leaf destination-deletion-timestamp { | | leaf destination-deletion-timestamp { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Destination deletion timestamp in seconds"; | | "Destination deletion timestamp in seconds"; |
| } | | } |
| leaf is-inter-area { | | leaf is-inter-area { |
| type boolean; | | type boolean; |
| description | | description |
| "Indicates whether this destination is in | | "Indicates whether this destination is in |
| different area"; | | different area"; |
| } | | } |
| list path-option-entry { | | list path-option-entry { |
| description | | description |
| "Deprecated; replaced by PathOption"; | | "Deprecated; replaced by PathOption"; |
| uses MPLS-TE-P2MP-PATH-OPTION; | | uses MPLS-TE-P2MP-PATH-OPTION; |
| } | | } |
| list path-option { | | list path-option { |
| description | | description |
| "Destination's list of path options"; | | "Destination's list of path options"; |
| uses MPLS-TE-P2MP-PATH-OPTION; | | uses MPLS-TE-P2MP-PATH-OPTION; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-TUNNEL-LOGGING { | | grouping MPLS-TE-TUNNEL-LOGGING { |
| description | | description |
| "Tunnel Logging Attributes"; | | "Tunnel Logging Attributes"; |
| leaf all { | | leaf all { |
| type boolean; | | type boolean; |
| description | | description |
| "All tunnel logging enabled"; | | "All tunnel logging enabled"; |
| } | | } |
| leaf reoptimize { | | leaf reoptimize { |
| type boolean; | | type boolean; |
| description | | description |
| "Reoptimization Logging"; | | "Reoptimization Logging"; |
| } | | } |
| leaf state { | | leaf state { |
| type boolean; | | type boolean; |
| description | | description |
| "State Logging"; | | "State Logging"; |
| } | | } |
| leaf reroute { | | leaf reroute { |
| type boolean; | | type boolean; |
| description | | description |
| "Reroute logging"; | | "Reroute logging"; |
| } | | } |
| leaf bandwidth-change { | | leaf bandwidth-change { |
| type boolean; | | type boolean; |
| description | | description |
| "Bandwidth change logging"; | | "Bandwidth change logging"; |
| } | | } |
| leaf switchover { | | leaf switchover { |
| type boolean; | | type boolean; |
| description | | description |
| "Path protection switchover logging"; | | "Path protection switchover logging"; |
| } | | } |
| leaf record-route { | | leaf record-route { |
| type boolean; | | type boolean; |
| description | | description |
| "Record route logging"; | | "Record route logging"; |
| } | | } |
| leaf path-calculation-failure { | | leaf path-calculation-failure { |
| type boolean; | | type boolean; |
| description | | description |
| "Path calculation failure logging"; | | "Path calculation failure logging"; |
| } | | } |
| leaf reoptimization-attempt { | | leaf reoptimization-attempt { |
| type boolean; | | type boolean; |
| description | | description |
| "Reoptimization attempt logging"; | | "Reoptimization attempt logging"; |
| } | | } |
| leaf insufficient-bandwidth { | | leaf insufficient-bandwidth { |
| type boolean; | | type boolean; |
| description | | description |
| "Insufficient bandwidth logging"; | | "Insufficient bandwidth logging"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-AUTOROUTE-DESTINATION-BAG { | | grouping MPLS-TE-AUTOROUTE-DESTINATION-BAG { |
| description | | description |
| "An Autoroute destination"; | | "An Autoroute destination"; |
| leaf destination-address { | | leaf destination-address { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Destination address"; | | "Destination address"; |
| } | | } |
| leaf prefix-length { | | leaf prefix-length { |
| type uint16; | | type uint16; |
| description | | description |
| "Prefix length"; | | "Prefix length"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-TUNNEL-BFD-CONFIG-INFO { | | grouping MPLS-TE-TUNNEL-BFD-CONFIG-INFO { |
| description | | description |
| "BFD configuration info for a tunnel"; | | "BFD configuration info for a tunnel"; |
| leaf bfd-fast-detecting-enabled { | | leaf bfd-fast-detecting-enabled { |
| type boolean; | | type boolean; |
| description | | description |
| "Deprecated"; | | "Deprecated"; |
| } | | } |
| leaf bfd-type { | | leaf bfd-type { |
| type Te-vif-bfd; | | type Te-vif-bfd; |
| description | | description |
| "BFD Type"; | | "BFD Type"; |
| } | | } |
| leaf min-interval { | | leaf min-interval { |
| type uint32; | | type uint32; |
| units "millisecond"; | | units "millisecond"; |
| description | | description |
| "Hello interval in milliseconds"; | | "Hello interval in milliseconds"; |
| } | | } |
| leaf min-interval-default { | | leaf min-interval-default { |
| type boolean; | | type boolean; |
| description | | description |
| "Is default hello interval"; | | "Is default hello interval"; |
| } | | } |
| leaf multiplier { | | leaf multiplier { |
| type uint8; | | type uint8; |
| description | | description |
| "Multiplier"; | | "Multiplier"; |
| } | | } |
| leaf multiplier-default { | | leaf multiplier-default { |
| type boolean; | | type boolean; |
| description | | description |
| "Is default multiplier"; | | "Is default multiplier"; |
| } | | } |
| leaf bring-up-timeout { | | leaf bring-up-timeout { |
| type uint16; | | type uint16; |
| description | | description |
| "Bring Up Timeout in second"; | | "Bring Up Timeout in second"; |
| } | | } |
| leaf bring-up-timeout-default { | | leaf bring-up-timeout-default { |
| type boolean; | | type boolean; |
| description | | description |
| "Is default bring up timeout"; | | "Is default bring up timeout"; |
| } | | } |
| leaf dampening-initial-wait { | | leaf dampening-initial-wait { |
| type uint32; | | type uint32; |
| units "millisecond"; | | units "millisecond"; |
| description | | description |
| "Dampening initial wait time in milliseconds"; | | "Dampening initial wait time in milliseconds"; |
| } | | } |
| leaf dampening-initial-wait-default { | | leaf dampening-initial-wait-default { |
| type boolean; | | type boolean; |
| description | | description |
| "Is default dampening inital wait time"; | | "Is default dampening inital wait time"; |
| } | | } |
| leaf dampening-max-wait { | | leaf dampening-max-wait { |
| type uint32; | | type uint32; |
| units "millisecond"; | | units "millisecond"; |
| description | | description |
| "Dampening max wait time in milliseconds"; | | "Dampening max wait time in milliseconds"; |
| } | | } |
| leaf dampening-max-wait-default { | | leaf dampening-max-wait-default { |
| type boolean; | | type boolean; |
| description | | description |
| "Is default dampening max wait time"; | | "Is default dampening max wait time"; |
| } | | } |
| leaf dampening-secondary-wait { | | leaf dampening-secondary-wait { |
| type uint32; | | type uint32; |
| units "millisecond"; | | units "millisecond"; |
| description | | description |
| "Dampening secondary wait time in milliseconds"; | | "Dampening secondary wait time in milliseconds"; |
| } | | } |
| leaf dampening-secondary-wait-default { | | leaf dampening-secondary-wait-default { |
| type boolean; | | type boolean; |
| description | | description |
| "Is default dampening secondary wait time"; | | "Is default dampening secondary wait time"; |
| } | | } |
| leaf periodic-lsp-ping-disabled { | | leaf periodic-lsp-ping-disabled { |
| type boolean; | | type boolean; |
| description | | description |
| "Periodic LSP Ping disabled"; | | "Periodic LSP Ping disabled"; |
| } | | } |
| leaf periodic-lsp-ping-interval { | | leaf periodic-lsp-ping-interval { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Periodic LSP Ping interval in seconds"; | | "Periodic LSP Ping interval in seconds"; |
| } | | } |
| leaf periodic-lsp-ping-interval-default { | | leaf periodic-lsp-ping-interval-default { |
| type boolean; | | type boolean; |
| description | | description |
| "Is default LSP Ping interval"; | | "Is default LSP Ping interval"; |
| } | | } |
| leaf bfd-session-down-action { | | leaf bfd-session-down-action { |
| type Mpls-te-bfd-session-down-action1; | | type Mpls-te-bfd-session-down-action1; |
| description | | description |
| "BFD Session Down Action"; | | "BFD Session Down Action"; |
| } | | } |
| leaf bfd-session-down-reopt-timeout { | | leaf bfd-session-down-reopt-timeout { |
| type uint32; | | type uint32; |
| description | | description |
| "BFD Session Down Reopt Timeout"; | | "BFD Session Down Reopt Timeout"; |
| } | | } |
| leaf bfd-encap-mode { | | leaf bfd-encap-mode { |
| type Te-vif-bfd-encap-mode; | | type Te-vif-bfd-encap-mode; |
| description | | description |
| "BFD Encap Mode"; | | "BFD Encap Mode"; |
| } | | } |
| leaf sbfd-target-id { | | leaf sbfd-target-id { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "SBFD Target ID"; | | "SBFD Target ID"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-TUNNEL-BIDIR-CONFIG-INFO { | | grouping MPLS-TE-TUNNEL-BIDIR-CONFIG-INFO { |
| description | | description |
| "Bidirectional configuration info for a tunnel"; | | "Bidirectional configuration info for a tunnel"; |
| leaf association-type { | | leaf association-type { |
| type uint16; | | type uint16; |
| description | | description |
| "Association Type (RFC 7751)"; | | "Association Type (RFC 7751)"; |
| } | | } |
| leaf association-id { | | leaf association-id { |
| type uint16; | | type uint16; |
| description | | description |
| "The association ID"; | | "The association ID"; |
| } | | } |
| leaf association-source { | | leaf association-source { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "The association source"; | | "The association source"; |
| } | | } |
| leaf association-global-id { | | leaf association-global-id { |
| type uint32; | | type uint32; |
| description | | description |
| "The association global ID"; | | "The association global ID"; |
| } | | } |
| leaf association-corouted { | | leaf association-corouted { |
| type boolean; | | type boolean; |
| description | | description |
| "Is the association co-routed"; | | "Is the association co-routed"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-P2MP-TUN-CFG-BAG { | | grouping MPLS-TE-P2MP-TUN-CFG-BAG { |
| description | | description |
| "Configured P2MP tunnel data"; | | "Configured P2MP tunnel data"; |
| container affinity { | | container affinity { |
| description | | description |
| "Affinity"; | | "Affinity"; |
| uses MPLS-TE-TUNNELS-AFFINITY-INFO; | | uses MPLS-TE-TUNNELS-AFFINITY-INFO; |
| } | | } |
| container bidirectional-config { | | container bidirectional-config { |
| description | | description |
| "Bidirectional Configuration Information"; | | "Bidirectional Configuration Information"; |
| uses MPLS-TE-TUNNEL-BIDIR-CONFIG-INFO; | | uses MPLS-TE-TUNNEL-BIDIR-CONFIG-INFO; |
| } | | } |
| container bfd-config { | | container bfd-config { |
| description | | description |
| "BFD Configuration Information"; | | "BFD Configuration Information"; |
| uses MPLS-TE-TUNNEL-BFD-CONFIG-INFO; | | uses MPLS-TE-TUNNEL-BFD-CONFIG-INFO; |
| } | | } |
| container logging { | | container logging { |
| description | | description |
| "Logging configuration"; | | "Logging configuration"; |
| uses MPLS-TE-TUNNEL-LOGGING; | | uses MPLS-TE-TUNNEL-LOGGING; |
| } | | } |
| leaf tunnel-name { | | leaf tunnel-name { |
| type string; | | type string; |
| description | | description |
| "Tunnel name"; | | "Tunnel name"; |
| } | | } |
| leaf tunnel-id { | | leaf tunnel-id { |
| type uint32; | | type uint32; |
| description | | description |
| "Tunnel id"; | | "Tunnel id"; |
| } | | } |
| leaf is-p2mp { | | leaf is-p2mp { |
| type boolean; | | type boolean; |
| description | | description |
| "True if tunnel is a P2MP tunnel"; | | "True if tunnel is a P2MP tunnel"; |
| } | | } |
| leaf signaled-name { | | leaf signaled-name { |
| type string; | | type string; |
| description | | description |
| "Signaled name"; | | "Signaled name"; |
| } | | } |
| leaf configured-bandwidth { | | leaf configured-bandwidth { |
| type uint32; | | type uint32; |
| description | | description |
| "Configured Bandwidth"; | | "Configured Bandwidth"; |
| } | | } |
| leaf interface-configured-bandwidth { | | leaf interface-configured-bandwidth { |
| type uint32; | | type uint32; |
| description | | description |
| "Configured Interface Bandwidth"; | | "Configured Interface Bandwidth"; |
| } | | } |
| leaf bandwidth-type { | | leaf bandwidth-type { |
| type Mpls-te-bw-pool; | | type Mpls-te-bw-pool; |
| description | | description |
| "The bandwidth type"; | | "The bandwidth type"; |
| } | | } |
| leaf setup-priority { | | leaf setup-priority { |
| type uint8; | | type uint8; |
| description | | description |
| "Setup priority"; | | "Setup priority"; |
| } | | } |
| leaf hold-priority { | | leaf hold-priority { |
| type uint8; | | type uint8; |
| description | | description |
| "Hold priority"; | | "Hold priority"; |
| } | | } |
| leaf policy-class { | | leaf policy-class { |
| type uint8; | | type uint8; |
| description | | description |
| "deprecated"; | | "deprecated"; |
| } | | } |
| leaf forward-class { | | leaf forward-class { |
| type uint32; | | type uint32; |
| description | | description |
| "Forward class"; | | "Forward class"; |
| } | | } |
| leaf is-forward-class-configured { | | leaf is-forward-class-configured { |
| type boolean; | | type boolean; |
| description | | description |
| "True if Forward class is configured"; | | "True if Forward class is configured"; |
| } | | } |
| leaf backup-bandwidth { | | leaf backup-bandwidth { |
| type uint32; | | type uint32; |
| description | | description |
| "Backup bandwidth"; | | "Backup bandwidth"; |
| } | | } |
| leaf backup-bandwidth-flags { | | leaf backup-bandwidth-flags { |
| type uint8; | | type uint8; |
| description | | description |
| "Backup bandwidth flags"; | | "Backup bandwidth flags"; |
| } | | } |
| leaf config-load-share { | | leaf config-load-share { |
| type uint32; | | type uint32; |
| description | | description |
| "Config loadshare"; | | "Config loadshare"; |
| } | | } |
| leaf load-interval { | | leaf load-interval { |
| type uint32; | | type uint32; |
| description | | description |
| "Load interval used to compute traffic rate"; | | "Load interval used to compute traffic rate"; |
| } | | } |
| leaf payload-type { | | leaf payload-type { |
| type uint16; | | type uint16; |
| description | | description |
| "Payload type"; | | "Payload type"; |
| } | | } |
| leaf is-in-config { | | leaf is-in-config { |
| type boolean; | | type boolean; |
| description | | description |
| "Is in config"; | | "Is in config"; |
| } | | } |
| leaf explicit-null-imposition { | | leaf explicit-null-imposition { |
| type boolean; | | type boolean; |
| description | | description |
| "Imposition of Explicit NULL"; | | "Imposition of Explicit NULL"; |
| } | | } |
| leaf fast-reroute { | | leaf fast-reroute { |
| type boolean; | | type boolean; |
| description | | description |
| "Fast reroute enabled"; | | "Fast reroute enabled"; |
| } | | } |
| leaf is-backup-tunnel { | | leaf is-backup-tunnel { |
| type boolean; | | type boolean; |
| description | | description |
| "TRUE if this is a backup tunnel"; | | "TRUE if this is a backup tunnel"; |
| } | | } |
| leaf record-route { | | leaf record-route { |
| type boolean; | | type boolean; |
| description | | description |
| "Record route"; | | "Record route"; |
| } | | } |
| leaf srlg-discovery { | | leaf srlg-discovery { |
| type boolean; | | type boolean; |
| description | | description |
| "SRLG-discovery enabled"; | | "SRLG-discovery enabled"; |
| } | | } |
| leaf path-protection-enabled { | | leaf path-protection-enabled { |
| type boolean; | | type boolean; |
| description | | description |
| "Path Protection enabled"; | | "Path Protection enabled"; |
| } | | } |
| leaf path-protection-srlg-diversity { | | leaf path-protection-srlg-diversity { |
| type boolean; | | type boolean; |
| description | | description |
| "SRLG Diversity for Path Protection Enabled"; | | "SRLG Diversity for Path Protection Enabled"; |
| } | | } |
| leaf path-protection-non-revertive { | | leaf path-protection-non-revertive { |
| type boolean; | | type boolean; |
| description | | description |
| "Non-revertive mode for Path Protection Enabled"; | | "Non-revertive mode for Path Protection Enabled"; |
| } | | } |
| leaf hop-limit { | | leaf hop-limit { |
| type uint8; | | type uint8; |
| description | | description |
| "Hop Limit"; | | "Hop Limit"; |
| } | | } |
| leaf cost-limit { | | leaf cost-limit { |
| type uint32; | | type uint32; |
| description | | description |
| "Cost limit on the tunnel path"; | | "Cost limit on the tunnel path"; |
| } | | } |
| leaf cost-limit-global { | | leaf cost-limit-global { |
| type uint32; | | type uint32; |
| description | | description |
| "Global Cost Limit"; | | "Global Cost Limit"; |
| } | | } |
| leaf delay-limit { | | leaf delay-limit { |
| type uint32; | | type uint32; |
| description | | description |
| "Delay limit on the tunnel path (usec)"; | | "Delay limit on the tunnel path (usec)"; |
| } | | } |
| leaf delay-limit-global { | | leaf delay-limit-global { |
| type uint32; | | type uint32; |
| description | | description |
| "Global Delay Limit (usec)"; | | "Global Delay Limit (usec)"; |
| } | | } |
| leaf delay-measurement-enabled { | | leaf delay-measurement-enabled { |
| type boolean; | | type boolean; |
| description | | description |
| "Delay-measurement enabled"; | | "Delay-measurement enabled"; |
| } | | } |
| leaf path-invalidation-timeout-source { | | leaf path-invalidation-timeout-source { |
| type uint32; | | type uint32; |
| description | | description |
| "Path invalidation timeout configuration source"; | | "Path invalidation timeout configuration source"; |
| } | | } |
| leaf path-invalidation-timeout { | | leaf path-invalidation-timeout { |
| type uint32; | | type uint32; |
| description | | description |
| "Path invalidation timeout interval on the tunnel | | "Path invalidation timeout interval on the tunnel |
| path"; | | path"; |
| } | | } |
| leaf path-invalidation-action-source { | | leaf path-invalidation-action-source { |
| type uint32; | | type uint32; |
| description | | description |
| "Path invalidation action configuration source"; | | "Path invalidation action configuration source"; |
| } | | } |
| leaf path-invalidation-action { | | leaf path-invalidation-action { |
| type uint32; | | type uint32; |
| description | | description |
| "Path invalidation action on the tunnel path"; | | "Path invalidation action on the tunnel path"; |
| } | | } |
| leaf soft-preempt { | | leaf soft-preempt { |
| type boolean; | | type boolean; |
| description | | description |
| "Soft preemption enabled"; | | "Soft preemption enabled"; |
| } | | } |
| leaf disable-affinity-failure-reopt { | | leaf disable-affinity-failure-reopt { |
| type boolean; | | type boolean; |
| description | | description |
| "DisableAffinityFailureReopt"; | | "DisableAffinityFailureReopt"; |
| } | | } |
| leaf affinity-failure-reopt-timer { | | leaf affinity-failure-reopt-timer { |
| type uint32; | | type uint32; |
| description | | description |
| "AffinityFailureReoptTimer"; | | "AffinityFailureReoptTimer"; |
| } | | } |
| leaf segment-routing-path-selection { | | leaf segment-routing-path-selection { |
| type Te-s2l-sr-path-selection; | | type Te-s2l-sr-path-selection; |
| description | | description |
| "Segment-Routing path selection type"; | | "Segment-Routing path selection type"; |
| } | | } |
| n | leaf is-self-ping-configured { | n | |
| type boolean; | | |
| description | | |
| "TRUE if self-ping is configured, FALSE otherwise"; | | |
| } | | |
| leaf self-ping-probes-maximum { | | |
| type uint16; | | |
| description | | |
| "Number of maximum probes sent before failing | | |
| self-ping"; | | |
| } | | |
| leaf self-ping-retry-period { | | |
| type uint8; | | |
| units "second"; | | |
| description | | |
| "Number of seconds between self-ping retries"; | | |
| } | | |
| leaf source-address { | | |
| type inet:ipv4-address; | | |
| description | | |
| "Source address"; | | |
| } | | |
| list policy-class-entry { | | list policy-class-entry { |
| description | | description |
| "PBTS policy classes"; | | "PBTS policy classes"; |
| leaf entry { | | leaf entry { |
| type uint8; | | type uint8; |
| description | | description |
| "PBTS policy classes"; | | "PBTS policy classes"; |
| } | | } |
| } | | } |
| list autoroute-destination { | | list autoroute-destination { |
| description | | description |
| "Autoroute Destinations list"; | | "Autoroute Destinations list"; |
| uses MPLS-TE-AUTOROUTE-DESTINATION-BAG; | | uses MPLS-TE-AUTOROUTE-DESTINATION-BAG; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-P2MP-TUNNEL-BAG { | | grouping MPLS-TE-P2MP-TUNNEL-BAG { |
| description | | description |
| "P2MP tunnel data"; | | "P2MP tunnel data"; |
| container config { | | container config { |
| description | | description |
| "Configuration data"; | | "Configuration data"; |
| uses MPLS-TE-P2MP-TUN-CFG-BAG; | | uses MPLS-TE-P2MP-TUN-CFG-BAG; |
| } | | } |
| container tunnel-current-lsp { | | container tunnel-current-lsp { |
| description | | description |
| "Current LSP"; | | "Current LSP"; |
| uses MPLS-TE-P2MP-LSP; | | uses MPLS-TE-P2MP-LSP; |
| } | | } |
| container reoptimized-p2mp-lsp { | | container reoptimized-p2mp-lsp { |
| description | | description |
| "Reopt LSP"; | | "Reopt LSP"; |
| uses MPLS-TE-P2MP-LSP; | | uses MPLS-TE-P2MP-LSP; |
| } | | } |
| container tunnel-standby-lsp { | | container tunnel-standby-lsp { |
| description | | description |
| "Standby LSP"; | | "Standby LSP"; |
| uses MPLS-TE-P2MP-LSP; | | uses MPLS-TE-P2MP-LSP; |
| } | | } |
| container reoptimized-standby-p2mp-lsp { | | container reoptimized-standby-p2mp-lsp { |
| description | | description |
| "Standby Reopt LSP"; | | "Standby Reopt LSP"; |
| uses MPLS-TE-P2MP-LSP; | | uses MPLS-TE-P2MP-LSP; |
| } | | } |
| container tunnel-restoration-lsp { | | container tunnel-restoration-lsp { |
| description | | description |
| "Restoration LSP"; | | "Restoration LSP"; |
| uses MPLS-TE-P2MP-LSP; | | uses MPLS-TE-P2MP-LSP; |
| } | | } |
| container delay-clean-pp-lsp { | | container delay-clean-pp-lsp { |
| description | | description |
| "Delay Clean PP LSP"; | | "Delay Clean PP LSP"; |
| uses MPLS-TE-P2MP-LSP; | | uses MPLS-TE-P2MP-LSP; |
| } | | } |
| container cleaned-lsp { | | container cleaned-lsp { |
| description | | description |
| "Cleaned LSP"; | | "Cleaned LSP"; |
| uses MPLS-TE-P2MP-LSP; | | uses MPLS-TE-P2MP-LSP; |
| } | | } |
| container p2p-info { | | container p2p-info { |
| description | | description |
| "P2P specific info"; | | "P2P specific info"; |
| uses MPLS-TE-P2P-INFO-BAG; | | uses MPLS-TE-P2P-INFO-BAG; |
| } | | } |
| container auto-capacity { | | container auto-capacity { |
| description | | description |
| "Auto-capacity Info"; | | "Auto-capacity Info"; |
| uses MPLS-TE-AUTOCAPACITY; | | uses MPLS-TE-AUTOCAPACITY; |
| } | | } |
| n | container self-ping { | n | |
| description | | |
| "Self-ping Info"; | | |
| uses MPLS-TE-SELF-PING; | | |
| } | | |
| container history { | | container history { |
| description | | description |
| "Tunnel history"; | | "Tunnel history"; |
| uses MPLS-TE-TUNNELS-HISTORY-BAG; | | uses MPLS-TE-TUNNELS-HISTORY-BAG; |
| } | | } |
| container path-protection { | | container path-protection { |
| description | | description |
| "Path Protect Info"; | | "Path Protect Info"; |
| uses MPLS-TE-PP-INFO; | | uses MPLS-TE-PP-INFO; |
| } | | } |
| container auto-backup { | | container auto-backup { |
| description | | description |
| "Autobackup Information"; | | "Autobackup Information"; |
| uses MPLS-TE-AUTOBACKUP-INFO; | | uses MPLS-TE-AUTOBACKUP-INFO; |
| } | | } |
| container auto-mesh { | | container auto-mesh { |
| description | | description |
| "Automesh Information"; | | "Automesh Information"; |
| uses MPLS-TE-AUTOMESH-INFO; | | uses MPLS-TE-AUTOMESH-INFO; |
| } | | } |
| container auto-pcc { | | container auto-pcc { |
| description | | description |
| "Auto-PCC Information"; | | "Auto-PCC Information"; |
| uses MPLS-TE-AUTOPCC-INFO; | | uses MPLS-TE-AUTOPCC-INFO; |
| } | | } |
| container pce-delegation { | | container pce-delegation { |
| description | | description |
| "PCE Delegation information"; | | "PCE Delegation information"; |
| uses MPLS-TE-PCE-DELEGATION-INFO; | | uses MPLS-TE-PCE-DELEGATION-INFO; |
| } | | } |
| container soft-preemption { | | container soft-preemption { |
| description | | description |
| "Tunnel head soft preemption info. This is NULL | | "Tunnel head soft preemption info. This is NULL |
| if soft preemption is not configured"; | | if soft preemption is not configured"; |
| uses MPLS-TE-SOFT-PREEMPTION-TUNNEL-INFO; | | uses MPLS-TE-SOFT-PREEMPTION-TUNNEL-INFO; |
| } | | } |
| container wdm-unitunnel { | | container wdm-unitunnel { |
| description | | description |
| "WDM-UNI tunnel data. Only exists for WDM-UNI | | "WDM-UNI tunnel data. Only exists for WDM-UNI |
| tunnels"; | | tunnels"; |
| uses MPLS-TE-MGMT-WDM-UNI-TUNNEL-INFO; | | uses MPLS-TE-MGMT-WDM-UNI-TUNNEL-INFO; |
| } | | } |
| container transport-tunnel-info { | | container transport-tunnel-info { |
| description | | description |
| "Transport tunnel data. Only exists for Transport | | "Transport tunnel data. Only exists for Transport |
| tunnels"; | | tunnels"; |
| uses MPLS-TE-TRANSPORT-TUNNEL-INFO; | | uses MPLS-TE-TRANSPORT-TUNNEL-INFO; |
| } | | } |
| container bfd-info { | | container bfd-info { |
| description | | description |
| "BFD session info. This is NULL if BFD is not | | "BFD session info. This is NULL if BFD is not |
| configured"; | | configured"; |
| uses MPLS-TE-TUNNEL-BFD-INFO; | | uses MPLS-TE-TUNNEL-BFD-INFO; |
| } | | } |
| container otn-bidir { | | container otn-bidir { |
| description | | description |
| "OTN bidir info"; | | "OTN bidir info"; |
| uses MPLS-TE-TUNNEL-OTN-BIDIR-INFO; | | uses MPLS-TE-TUNNEL-OTN-BIDIR-INFO; |
| } | | } |
| container bidir { | | container bidir { |
| description | | description |
| "Bidir info"; | | "Bidir info"; |
| uses MPLS-TE-TUNNEL-BIDIR-INFO; | | uses MPLS-TE-TUNNEL-BIDIR-INFO; |
| } | | } |
| container xro-attribute-set { | | container xro-attribute-set { |
| description | | description |
| "XRO attribute-set"; | | "XRO attribute-set"; |
| uses MPLS-TE-ATTRIBUTE-SET; | | uses MPLS-TE-ATTRIBUTE-SET; |
| } | | } |
| container te-tunnel-convergence { | | container te-tunnel-convergence { |
| description | | description |
| "TE tunnel convergence related information"; | | "TE tunnel convergence related information"; |
| uses TE-VIF-CONVERGENCE-INFO; | | uses TE-VIF-CONVERGENCE-INFO; |
| } | | } |
| container flex-info { | | container flex-info { |
| description | | description |
| "Flex Info"; | | "Flex Info"; |
| uses MPLS-TE-TUNNEL-FLEX-INFO; | | uses MPLS-TE-TUNNEL-FLEX-INFO; |
| } | | } |
| container sticky-working-path { | | container sticky-working-path { |
| description | | description |
| "Sticky working Path"; | | "Sticky working Path"; |
| uses MPLS-TE-STICKY-PATH; | | uses MPLS-TE-STICKY-PATH; |
| } | | } |
| container sticky-protecting-path { | | container sticky-protecting-path { |
| description | | description |
| "Sticky protecting Path"; | | "Sticky protecting Path"; |
| uses MPLS-TE-STICKY-PATH; | | uses MPLS-TE-STICKY-PATH; |
| } | | } |
| leaf role-standby { | | leaf role-standby { |
| type boolean; | | type boolean; |
| description | | description |
| "TRUE if Role is Standby, Active otherwise"; | | "TRUE if Role is Standby, Active otherwise"; |
| } | | } |
| leaf tunnel-interface-name { | | leaf tunnel-interface-name { |
| type xr:Interface-name; | | type xr:Interface-name; |
| description | | description |
| "Interface handle of the associated tunnel"; | | "Interface handle of the associated tunnel"; |
| } | | } |
| leaf admin-state { | | leaf admin-state { |
| type Mte-tunnel-admin-state; | | type Mte-tunnel-admin-state; |
| description | | description |
| "Administrative State"; | | "Administrative State"; |
| } | | } |
| leaf operational-state { | | leaf operational-state { |
| type Mte-tunnel-oper-state; | | type Mte-tunnel-oper-state; |
| description | | description |
| "Operational State"; | | "Operational State"; |
| } | | } |
| leaf operational-state-changes { | | leaf operational-state-changes { |
| type uint32; | | type uint32; |
| description | | description |
| "Counters for operational state changes"; | | "Counters for operational state changes"; |
| } | | } |
| leaf signaled-name { | | leaf signaled-name { |
| type string; | | type string; |
| description | | description |
| "Signaled Name"; | | "Signaled Name"; |
| } | | } |
| leaf fail-reason { | | leaf fail-reason { |
| type Mpls-mte-tunnel-fail-reason; | | type Mpls-mte-tunnel-fail-reason; |
| description | | description |
| "The reason why failure occurred"; | | "The reason why failure occurred"; |
| } | | } |
| leaf destination-up-count { | | leaf destination-up-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Count of up destinations"; | | "Count of up destinations"; |
| } | | } |
| leaf destination-disabled-count { | | leaf destination-disabled-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Count of disabled destinations"; | | "Count of disabled destinations"; |
| } | | } |
| leaf destination-down-count { | | leaf destination-down-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Count of down destinations"; | | "Count of down destinations"; |
| } | | } |
| leaf re-opt-hold-down-timer-remaining { | | leaf re-opt-hold-down-timer-remaining { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Backup hold-down timer remaining time in seconds"; | | "Backup hold-down timer remaining time in seconds"; |
| } | | } |
| leaf bandwidth-requested { | | leaf bandwidth-requested { |
| type uint32; | | type uint32; |
| description | | description |
| "Bandwidth Requested"; | | "Bandwidth Requested"; |
| } | | } |
| leaf bandwidth-type { | | leaf bandwidth-type { |
| type Mpls-te-bw-pool; | | type Mpls-te-bw-pool; |
| description | | description |
| "The requested bandwidth type"; | | "The requested bandwidth type"; |
| } | | } |
| leaf is-node-protected { | | leaf is-node-protected { |
| type boolean; | | type boolean; |
| description | | description |
| "Node Protection Enabled or Disabled"; | | "Node Protection Enabled or Disabled"; |
| } | | } |
| leaf is-bandwidth-protect { | | leaf is-bandwidth-protect { |
| type boolean; | | type boolean; |
| description | | description |
| "BW Protection Enabled or Disabled"; | | "BW Protection Enabled or Disabled"; |
| } | | } |
| leaf tunnel-recovering { | | leaf tunnel-recovering { |
| type boolean; | | type boolean; |
| description | | description |
| "Tunnel recovering"; | | "Tunnel recovering"; |
| } | | } |
| leaf reroute-pending { | | leaf reroute-pending { |
| type boolean; | | type boolean; |
| description | | description |
| "ReroutePending"; | | "ReroutePending"; |
| } | | } |
| leaf explicit-path-change { | | leaf explicit-path-change { |
| type boolean; | | type boolean; |
| description | | description |
| "Explicit-path inuse by the current LSP has been | | "Explicit-path inuse by the current LSP has been |
| modified"; | | modified"; |
| } | | } |
| leaf path-option-change { | | leaf path-option-change { |
| type boolean; | | type boolean; |
| description | | description |
| "Path-Option inuse by the current LSP has been | | "Path-Option inuse by the current LSP has been |
| modified"; | | modified"; |
| } | | } |
| leaf affinity-failure-reopt-disabled { | | leaf affinity-failure-reopt-disabled { |
| type boolean; | | type boolean; |
| description | | description |
| "AffinityFailureReoptDisabled"; | | "AffinityFailureReoptDisabled"; |
| } | | } |
| leaf affinity-failure-reopt-time-remained { | | leaf affinity-failure-reopt-time-remained { |
| type uint32; | | type uint32; |
| description | | description |
| "AffinityFailureReoptTimeRemained"; | | "AffinityFailureReoptTimeRemained"; |
| } | | } |
| leaf affinity-failure-delayed-tear-time-remained { | | leaf affinity-failure-delayed-tear-time-remained { |
| type uint32; | | type uint32; |
| description | | description |
| "Affinity Failure LSP tear down time remaining"; | | "Affinity Failure LSP tear down time remaining"; |
| } | | } |
| leaf invalidation-time-remained { | | leaf invalidation-time-remained { |
| type uint32; | | type uint32; |
| description | | description |
| "Path invalidation time remaining"; | | "Path invalidation time remaining"; |
| } | | } |
| leaf drop-mode { | | leaf drop-mode { |
| type boolean; | | type boolean; |
| description | | description |
| "True if tunnel is in drop mode"; | | "True if tunnel is in drop mode"; |
| } | | } |
| leaf auto-route { | | leaf auto-route { |
| type boolean; | | type boolean; |
| description | | description |
| "IGP Auto route announce enabled"; | | "IGP Auto route announce enabled"; |
| } | | } |
| leaf forwarding-adjacency { | | leaf forwarding-adjacency { |
| type boolean; | | type boolean; |
| description | | description |
| "IGP forwarding adjacency enabled"; | | "IGP forwarding adjacency enabled"; |
| } | | } |
| leaf load-share-factor { | | leaf load-share-factor { |
| type uint32; | | type uint32; |
| description | | description |
| "The specified loadsharing for the tunnel"; | | "The specified loadsharing for the tunnel"; |
| } | | } |
| leaf load-share-type { | | leaf load-share-type { |
| type Mpls-te-loadshare; | | type Mpls-te-loadshare; |
| description | | description |
| "Loadsharing type"; | | "Loadsharing type"; |
| } | | } |
| leaf create-time { | | leaf create-time { |
| type uint32; | | type uint32; |
| description | | description |
| "Time at which the tunnel was created"; | | "Time at which the tunnel was created"; |
| } | | } |
| leaf uptime { | | leaf uptime { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Time in seconds since the tunnel was up"; | | "Time in seconds since the tunnel was up"; |
| } | | } |
| leaf metric-type { | | leaf metric-type { |
| type Mpls-te-metric; | | type Mpls-te-metric; |
| description | | description |
| "The path selection metric"; | | "The path selection metric"; |
| } | | } |
| leaf tie-breaker { | | leaf tie-breaker { |
| type Te-path-selection-tiebreaker; | | type Te-path-selection-tiebreaker; |
| description | | description |
| "The path selection tiebreaker"; | | "The path selection tiebreaker"; |
| } | | } |
| leaf tiebreaker-type { | | leaf tiebreaker-type { |
| type uint32; | | type uint32; |
| description | | description |
| "Deprecated - replaced by Tiebreaker"; | | "Deprecated - replaced by Tiebreaker"; |
| } | | } |
| leaf tiebreaker-qualifier { | | leaf tiebreaker-qualifier { |
| type Mpls-te-metric-qualifier; | | type Mpls-te-metric-qualifier; |
| description | | description |
| "Describes how the path selection tiebreaker was | | "Describes how the path selection tiebreaker was |
| specified: default, globally set, or per | | specified: default, globally set, or per |
| interface"; | | interface"; |
| } | | } |
| leaf metric-qualifier { | | leaf metric-qualifier { |
| type Mpls-te-metric-qualifier; | | type Mpls-te-metric-qualifier; |
| description | | description |
| "Describe how the metric was specified: default, | | "Describe how the metric was specified: default, |
| globally set, or per interface"; | | globally set, or per interface"; |
| } | | } |
| leaf is-hop-limit-ignore { | | leaf is-hop-limit-ignore { |
| type boolean; | | type boolean; |
| description | | description |
| "Is Hop-limit ignored"; | | "Is Hop-limit ignored"; |
| } | | } |
| leaf hop-limit-ignored-reason { | | leaf hop-limit-ignored-reason { |
| type Te-hop-limit-ignore; | | type Te-hop-limit-ignore; |
| description | | description |
| "Hop-limit ignored reason"; | | "Hop-limit ignored reason"; |
| } | | } |
| leaf outbound-frr-state { | | leaf outbound-frr-state { |
| type Mpls-te-frr-state; | | type Mpls-te-frr-state; |
| description | | description |
| "Indicates outbound FRR state"; | | "Indicates outbound FRR state"; |
| } | | } |
| leaf area-id { | | leaf area-id { |
| type string; | | type string; |
| description | | description |
| "Indicates the protocol and area used to find | | "Indicates the protocol and area used to find |
| Outgoing ERO"; | | Outgoing ERO"; |
| } | | } |
| leaf pce-fail-reason { | | leaf pce-fail-reason { |
| type Mpls-te-pce-fail-reasons; | | type Mpls-te-pce-fail-reasons; |
| description | | description |
| "Failure reason for PCE-based tunnels"; | | "Failure reason for PCE-based tunnels"; |
| } | | } |
| leaf snmp-index { | | leaf snmp-index { |
| type uint32; | | type uint32; |
| description | | description |
| "SNMP index for interface"; | | "SNMP index for interface"; |
| } | | } |
| leaf is-inter-area-tunnel { | | leaf is-inter-area-tunnel { |
| type boolean; | | type boolean; |
| description | | description |
| "Indicates whether this tunnel spans multiple | | "Indicates whether this tunnel spans multiple |
| areas."; | | areas."; |
| } | | } |
| leaf is-auto-backup { | | leaf is-auto-backup { |
| type boolean; | | type boolean; |
| description | | description |
| "Indicates whether this is an automatically | | "Indicates whether this is an automatically |
| generated backup tunnel"; | | generated backup tunnel"; |
| } | | } |
| leaf is-auto-pcc { | | leaf is-auto-pcc { |
| type boolean; | | type boolean; |
| description | | description |
| "Indicates whether this is an automatic PCC | | "Indicates whether this is an automatic PCC |
| tunnel"; | | tunnel"; |
| } | | } |
| leaf is-pce-delegated { | | leaf is-pce-delegated { |
| type boolean; | | type boolean; |
| description | | description |
| "Indicates whether this tunnel is delegated to a | | "Indicates whether this tunnel is delegated to a |
| PCE server or not"; | | PCE server or not"; |
| } | | } |
| leaf tunnel-attribute-set-name { | | leaf tunnel-attribute-set-name { |
| type string; | | type string; |
| description | | description |
| "AttributeSet name"; | | "AttributeSet name"; |
| } | | } |
| leaf tunnel-attribute-set-type { | | leaf tunnel-attribute-set-type { |
| type Tunnel-attribute-set; | | type Tunnel-attribute-set; |
| description | | description |
| "AttributeSet type"; | | "AttributeSet type"; |
| } | | } |
| leaf xro-attribute-set-name { | | leaf xro-attribute-set-name { |
| type string; | | type string; |
| description | | description |
| "Configured XRO attribute-set name"; | | "Configured XRO attribute-set name"; |
| } | | } |
| leaf is-passive { | | leaf is-passive { |
| type boolean; | | type boolean; |
| description | | description |
| "True for passive tunnel"; | | "True for passive tunnel"; |
| } | | } |
| leaf passive-tunnel-name { | | leaf passive-tunnel-name { |
| type string; | | type string; |
| description | | description |
| "Passive tunnel name"; | | "Passive tunnel name"; |
| } | | } |
| leaf binding-label-exists { | | leaf binding-label-exists { |
| type boolean; | | type boolean; |
| description | | description |
| "True, if binding label exists"; | | "True, if binding label exists"; |
| } | | } |
| leaf binding-label { | | leaf binding-label { |
| type uint32; | | type uint32; |
| description | | description |
| "Binding Label"; | | "Binding Label"; |
| } | | } |
| leaf last-hop-ifindex { | | leaf last-hop-ifindex { |
| type uint32; | | type uint32; |
| description | | description |
| "Termination destination ifindex"; | | "Termination destination ifindex"; |
| } | | } |
| leaf is-named { | | leaf is-named { |
| type boolean; | | type boolean; |
| description | | description |
| "Indicates whether this tunnel is named"; | | "Indicates whether this tunnel is named"; |
| } | | } |
| leaf lsp-wrap-protection-enabled { | | leaf lsp-wrap-protection-enabled { |
| type boolean; | | type boolean; |
| description | | description |
| "Lsp-wrap Protection enabled"; | | "Lsp-wrap Protection enabled"; |
| } | | } |
| leaf lsp-wrap-label { | | leaf lsp-wrap-label { |
| type uint32; | | type uint32; |
| description | | description |
| "Lsp-wrap label value"; | | "Lsp-wrap label value"; |
| } | | } |
| leaf is-interface { | | leaf is-interface { |
| type boolean; | | type boolean; |
| description | | description |
| "True for tunnel head"; | | "True for tunnel head"; |
| } | | } |
| leaf last-path-change { | | leaf last-path-change { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Time in seconds since the last path change"; | | "Time in seconds since the last path change"; |
| } | | } |
| leaf persistent-bytes { | | leaf persistent-bytes { |
| type uint64; | | type uint64; |
| units "byte"; | | units "byte"; |
| description | | description |
| "Persistent forwarding statistics for number of | | "Persistent forwarding statistics for number of |
| bytes. Clear counters will not reset the counter"; | | bytes. Clear counters will not reset the counter"; |
| } | | } |
| leaf persistent-packets { | | leaf persistent-packets { |
| type uint64; | | type uint64; |
| description | | description |
| "Persistent forwarding statistics for Number of | | "Persistent forwarding statistics for Number of |
| packets. Clear counters will not reset the | | packets. Clear counters will not reset the |
| counter"; | | counter"; |
| } | | } |
| leaf autoroute-announce-exclude-segment-routing { | | leaf autoroute-announce-exclude-segment-routing { |
| type boolean; | | type boolean; |
| description | | description |
| "Indicates whether this tunnel is autoroute | | "Indicates whether this tunnel is autoroute |
| announced with exclude segment-routing option"; | | announced with exclude segment-routing option"; |
| } | | } |
| n | leaf autoroute-announce-exclude-segment-routing-all { | n | |
| type boolean; | | |
| description | | |
| "Indicates whether this tunnel is autoroute | | |
| announced with exclude segment-routing-all | | |
| option"; | | |
| } | | |
| leaf last-working-lsp-id { | | leaf last-working-lsp-id { |
| type uint16; | | type uint16; |
| description | | description |
| "LSP-id of last working LSP"; | | "LSP-id of last working LSP"; |
| n | } | n | |
| leaf is-reoptimize-timer-config { | | |
| type boolean; | | |
| description | | |
| "True if reoptimize timer is configured"; | | |
| } | | |
| leaf reoptimization-period { | | |
| type uint16; | | |
| units "second"; | | |
| description | | |
| "Tunnel reoptimization period in seconds"; | | |
| } | | |
| leaf time-left-till-next-reoptimize { | | |
| type uint16; | | |
| units "second"; | | |
| description | | |
| "Time left till next reoptimization in seconds"; | | |
| } | | } |
| list destination { | | list destination { |
| description | | description |
| "Destinations array"; | | "Destinations array"; |
| uses MPLS-TE-P2MP-DEST; | | uses MPLS-TE-P2MP-DEST; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-S2L-DELAY-MEASUREMENT { | | grouping MPLS-TE-S2L-DELAY-MEASUREMENT { |
| description | | description |
| "S2L delay-measurement"; | | "S2L delay-measurement"; |
| leaf minimum-delay { | | leaf minimum-delay { |
| type uint32; | | type uint32; |
| units "microsecond"; | | units "microsecond"; |
| description | | description |
| "Minimum delay in microseconds"; | | "Minimum delay in microseconds"; |
| } | | } |
| leaf maximum-delay { | | leaf maximum-delay { |
| type uint32; | | type uint32; |
| units "microsecond"; | | units "microsecond"; |
| description | | description |
| "Maximum delay in microseconds"; | | "Maximum delay in microseconds"; |
| } | | } |
| leaf average-delay { | | leaf average-delay { |
| type uint32; | | type uint32; |
| units "microsecond"; | | units "microsecond"; |
| description | | description |
| "Average delay in microseconds"; | | "Average delay in microseconds"; |
| } | | } |
| leaf notification-timestamp { | | leaf notification-timestamp { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Notification timestamp, seconds since epoch"; | | "Notification timestamp, seconds since epoch"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-PATH-METRICS { | | grouping MPLS-TE-PATH-METRICS { |
| description | | description |
| "Path metrics info"; | | "Path metrics info"; |
| leaf te-metric { | | leaf te-metric { |
| type uint64; | | type uint64; |
| description | | description |
| "Path TE Metric"; | | "Path TE Metric"; |
| } | | } |
| leaf igp-metric { | | leaf igp-metric { |
| type uint64; | | type uint64; |
| description | | description |
| "Path IGP Metric"; | | "Path IGP Metric"; |
| } | | } |
| leaf delay-metric { | | leaf delay-metric { |
| type uint64; | | type uint64; |
| description | | description |
| "Path Delay Metric"; | | "Path Delay Metric"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-S2L-DIVERSITY-INFO { | | grouping MPLS-TE-S2L-DIVERSITY-INFO { |
| description | | description |
| "S2l Diversity info"; | | "S2l Diversity info"; |
| leaf diversity-type { | | leaf diversity-type { |
| type Te-pp-diversity; | | type Te-pp-diversity; |
| description | | description |
| "S2L path diversity type"; | | "S2L path diversity type"; |
| } | | } |
| } | | } |
| | | |
| grouping TUNNEL-MIDPOINT-LSP-WRAP-INFO-BAG { | | grouping TUNNEL-MIDPOINT-LSP-WRAP-INFO-BAG { |
| description | | description |
| "Midpoint LSP Wrap Protection LSP Info"; | | "Midpoint LSP Wrap Protection LSP Info"; |
| leaf lsp-wrap-protection-enable { | | leaf lsp-wrap-protection-enable { |
| type boolean; | | type boolean; |
| description | | description |
| "LSP Wrap protection enabled"; | | "LSP Wrap protection enabled"; |
| } | | } |
| leaf lsp-wrap-protection-label { | | leaf lsp-wrap-protection-label { |
| type uint32; | | type uint32; |
| description | | description |
| "LSP Wrap Merge Point Label"; | | "LSP Wrap Merge Point Label"; |
| } | | } |
| leaf reverse-egress-interface { | | leaf reverse-egress-interface { |
| type string; | | type string; |
| description | | description |
| "Reverse Egress Interface"; | | "Reverse Egress Interface"; |
| } | | } |
| leaf reverse-lsp-label { | | leaf reverse-lsp-label { |
| type uint32; | | type uint32; |
| description | | description |
| "Reverse LSP label"; | | "Reverse LSP label"; |
| } | | } |
| leaf lsp-wrap-protection-state { | | leaf lsp-wrap-protection-state { |
| type Mpls-te-lsp-wrap-state; | | type Mpls-te-lsp-wrap-state; |
| description | | description |
| "LSP wrap protection state"; | | "LSP wrap protection state"; |
| } | | } |
| } | | } |
| | | |
| grouping TE-S2L-SR-PATH-HOP { | | grouping TE-S2L-SR-PATH-HOP { |
| description | | description |
| "TE Segment-Routing S2L path hop"; | | "TE Segment-Routing S2L path hop"; |
| leaf sid-type { | | leaf sid-type { |
| type Te-sr-sid; | | type Te-sr-sid; |
| description | | description |
| "Type of the SID"; | | "Type of the SID"; |
| } | | } |
| leaf has-ip-addresses { | | leaf has-ip-addresses { |
| type boolean; | | type boolean; |
| description | | description |
| "Node has IP addresses specified"; | | "Node has IP addresses specified"; |
| } | | } |
| leaf local-addr { | | leaf local-addr { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Local IP address of adjacency or Node ID"; | | "Local IP address of adjacency or Node ID"; |
| } | | } |
| leaf remote-addr { | | leaf remote-addr { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Remote IP address of adjacency"; | | "Remote IP address of adjacency"; |
| } | | } |
| leaf has-mpls-label { | | leaf has-mpls-label { |
| type boolean; | | type boolean; |
| description | | description |
| "Hop has MPLS label specified"; | | "Hop has MPLS label specified"; |
| } | | } |
| leaf mpls-label-value { | | leaf mpls-label-value { |
| type uint32; | | type uint32; |
| description | | description |
| "The MPLS label value"; | | "The MPLS label value"; |
| } | | } |
| leaf has-entropy-label { | | leaf has-entropy-label { |
| type boolean; | | type boolean; |
| description | | description |
| "Hop has EL specified"; | | "Hop has EL specified"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-S2L-FLEX-INFO { | | grouping MPLS-TE-S2L-FLEX-INFO { |
| description | | description |
| "TE Per-S2L FlexLSP Information"; | | "TE Per-S2L FlexLSP Information"; |
| container flex-fec { | | container flex-fec { |
| description | | description |
| "FEC for the FlexLSP Entry"; | | "FEC for the FlexLSP Entry"; |
| uses TE-S2L-FEC; | | uses TE-S2L-FEC; |
| } | | } |
| leaf entry-exists { | | leaf entry-exists { |
| type boolean; | | type boolean; |
| description | | description |
| "FlexLSP Entry Exists"; | | "FlexLSP Entry Exists"; |
| } | | } |
| leaf in-label { | | leaf in-label { |
| type uint32; | | type uint32; |
| description | | description |
| "In Label"; | | "In Label"; |
| } | | } |
| leaf bfd-created { | | leaf bfd-created { |
| type boolean; | | type boolean; |
| description | | description |
| "GAL BFD Session Created"; | | "GAL BFD Session Created"; |
| } | | } |
| leaf bfd-up { | | leaf bfd-up { |
| type boolean; | | type boolean; |
| description | | description |
| "GAL BFD Session Up"; | | "GAL BFD Session Up"; |
| } | | } |
| leaf oam-created { | | leaf oam-created { |
| type boolean; | | type boolean; |
| description | | description |
| "OAM Entry Created"; | | "OAM Entry Created"; |
| } | | } |
| leaf bfd-next-hop { | | leaf bfd-next-hop { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "BFD Next Hop"; | | "BFD Next Hop"; |
| } | | } |
| leaf bfd-tun-ifh { | | leaf bfd-tun-ifh { |
| type xr:Interface-name; | | type xr:Interface-name; |
| description | | description |
| "BFD Tunnel Interface Handle"; | | "BFD Tunnel Interface Handle"; |
| } | | } |
| leaf bfd-out-ifh { | | leaf bfd-out-ifh { |
| type xr:Interface-name; | | type xr:Interface-name; |
| description | | description |
| "BFD Out Interface Handle"; | | "BFD Out Interface Handle"; |
| } | | } |
| leaf bfd-int-label { | | leaf bfd-int-label { |
| type uint32; | | type uint32; |
| description | | description |
| "BFD Internal Label"; | | "BFD Internal Label"; |
| } | | } |
| leaf bfd-egress-label { | | leaf bfd-egress-label { |
| type uint32; | | type uint32; |
| description | | description |
| "BFD Egress Label"; | | "BFD Egress Label"; |
| } | | } |
| leaf fault-ldi-lockout { | | leaf fault-ldi-lockout { |
| type boolean; | | type boolean; |
| description | | description |
| "Fault LDI Lockout"; | | "Fault LDI Lockout"; |
| } | | } |
| leaf fault-ldi { | | leaf fault-ldi { |
| type boolean; | | type boolean; |
| description | | description |
| "Fault LDI"; | | "Fault LDI"; |
| } | | } |
| leaf fault-lkr { | | leaf fault-lkr { |
| type boolean; | | type boolean; |
| description | | description |
| "Fault LKR"; | | "Fault LKR"; |
| } | | } |
| leaf fault-ais { | | leaf fault-ais { |
| type boolean; | | type boolean; |
| description | | description |
| "Fault AIS"; | | "Fault AIS"; |
| } | | } |
| leaf fault-time { | | leaf fault-time { |
| type uint32; | | type uint32; |
| description | | description |
| "Fault Time"; | | "Fault Time"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-S2L-PROTECTION-OBJECT { | | grouping MPLS-TE-S2L-PROTECTION-OBJECT { |
| description | | description |
| "TE Protection Object"; | | "TE Protection Object"; |
| leaf s2l-secondary { | | leaf s2l-secondary { |
| type boolean; | | type boolean; |
| description | | description |
| " S2L Protection Secondary Bit"; | | " S2L Protection Secondary Bit"; |
| } | | } |
| leaf s2l-protecting { | | leaf s2l-protecting { |
| type boolean; | | type boolean; |
| description | | description |
| " S2L Protection Protecting Bit"; | | " S2L Protection Protecting Bit"; |
| } | | } |
| leaf s2l-notification { | | leaf s2l-notification { |
| type boolean; | | type boolean; |
| description | | description |
| " S2L Protection Notification Bit"; | | " S2L Protection Notification Bit"; |
| } | | } |
| leaf s2l-operational { | | leaf s2l-operational { |
| type boolean; | | type boolean; |
| description | | description |
| " S2L Protection Operational Bit"; | | " S2L Protection Operational Bit"; |
| } | | } |
| leaf enhanced { | | leaf enhanced { |
| type boolean; | | type boolean; |
| description | | description |
| "Indicates Enhanced Protection Scheme"; | | "Indicates Enhanced Protection Scheme"; |
| } | | } |
| leaf ded1-plus1 { | | leaf ded1-plus1 { |
| type boolean; | | type boolean; |
| description | | description |
| "Dedicated 1+1 Protection"; | | "Dedicated 1+1 Protection"; |
| } | | } |
| leaf ded1-to1 { | | leaf ded1-to1 { |
| type boolean; | | type boolean; |
| description | | description |
| "Dedicated 1:1 Protection"; | | "Dedicated 1:1 Protection"; |
| } | | } |
| leaf shared { | | leaf shared { |
| type boolean; | | type boolean; |
| description | | description |
| "Shared Link Layer Protection"; | | "Shared Link Layer Protection"; |
| } | | } |
| leaf link-unprotected { | | leaf link-unprotected { |
| type boolean; | | type boolean; |
| description | | description |
| "LSP should not use any Link Layer Protection"; | | "LSP should not use any Link Layer Protection"; |
| } | | } |
| leaf extra-traffic { | | leaf extra-traffic { |
| type boolean; | | type boolean; |
| description | | description |
| "LSP should use Links that are protecting other | | "LSP should use Links that are protecting other |
| (primary) traffic"; | | (primary) traffic"; |
| } | | } |
| leaf any { | | leaf any { |
| type boolean; | | type boolean; |
| description | | description |
| "Any"; | | "Any"; |
| } | | } |
| leaf rerouting { | | leaf rerouting { |
| type boolean; | | type boolean; |
| description | | description |
| "Full Rerouting"; | | "Full Rerouting"; |
| } | | } |
| leaf rerouting-no-et { | | leaf rerouting-no-et { |
| type boolean; | | type boolean; |
| description | | description |
| "Rerouting Without Extra-Traffic"; | | "Rerouting Without Extra-Traffic"; |
| } | | } |
| leaf one-to-n-protection-et { | | leaf one-to-n-protection-et { |
| type boolean; | | type boolean; |
| description | | description |
| "1:N Protection with Extra-Traffic"; | | "1:N Protection with Extra-Traffic"; |
| } | | } |
| leaf one-plus-one-uni { | | leaf one-plus-one-uni { |
| type boolean; | | type boolean; |
| description | | description |
| "1+1 Unidirectional Protection"; | | "1+1 Unidirectional Protection"; |
| } | | } |
| leaf one-plus-one-bi { | | leaf one-plus-one-bi { |
| type boolean; | | type boolean; |
| description | | description |
| "1+1 Bidirectional Protection"; | | "1+1 Bidirectional Protection"; |
| } | | } |
| leaf lsp-unprotected { | | leaf lsp-unprotected { |
| type boolean; | | type boolean; |
| description | | description |
| "LSP Flags Unprotected"; | | "LSP Flags Unprotected"; |
| } | | } |
| leaf seg-rerouting { | | leaf seg-rerouting { |
| type boolean; | | type boolean; |
| description | | description |
| "Full Rerouting"; | | "Full Rerouting"; |
| } | | } |
| leaf seg-rerouting-no-et { | | leaf seg-rerouting-no-et { |
| type boolean; | | type boolean; |
| description | | description |
| "Rerouting Without Extra-Traffic"; | | "Rerouting Without Extra-Traffic"; |
| } | | } |
| leaf seg-one-to-n-protection-et { | | leaf seg-one-to-n-protection-et { |
| type boolean; | | type boolean; |
| description | | description |
| "1:N Protection with Extra-Traffic"; | | "1:N Protection with Extra-Traffic"; |
| } | | } |
| leaf seg-one-plus-one-uni { | | leaf seg-one-plus-one-uni { |
| type boolean; | | type boolean; |
| description | | description |
| "1+1 Unidirectional Protection"; | | "1+1 Unidirectional Protection"; |
| } | | } |
| leaf seg-one-plus-one-bi { | | leaf seg-one-plus-one-bi { |
| type boolean; | | type boolean; |
| description | | description |
| "1+1 Bidirectional Protection"; | | "1+1 Bidirectional Protection"; |
| } | | } |
| leaf seg-lsp-unprotected { | | leaf seg-lsp-unprotected { |
| type boolean; | | type boolean; |
| description | | description |
| "SEG Flags Unprotected"; | | "SEG Flags Unprotected"; |
| } | | } |
| leaf in-place-bit { | | leaf in-place-bit { |
| type boolean; | | type boolean; |
| description | | description |
| "In-Place Bit"; | | "In-Place Bit"; |
| } | | } |
| leaf required-bit { | | leaf required-bit { |
| type boolean; | | type boolean; |
| description | | description |
| "Required Bit"; | | "Required Bit"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-S2L-ASSOCIATION-OBJECT { | | grouping MPLS-TE-S2L-ASSOCIATION-OBJECT { |
| description | | description |
| "TE Association Object"; | | "TE Association Object"; |
| leaf s2l-association-type { | | leaf s2l-association-type { |
| type uint16; | | type uint16; |
| description | | description |
| "S2L Association Type | | "S2L Association Type |
| (draft-ietf-ccamp-mpls-tp-rsvpte-ext-associated-lsp)"; | | (draft-ietf-ccamp-mpls-tp-rsvpte-ext-associated-lsp)"; |
| } | | } |
| leaf s2l-association-tie-role { | | leaf s2l-association-tie-role { |
| type Te-association-tie-role; | | type Te-association-tie-role; |
| description | | description |
| "S2L Association Tie Role"; | | "S2L Association Tie Role"; |
| } | | } |
| leaf s2l-association-id { | | leaf s2l-association-id { |
| type uint16; | | type uint16; |
| description | | description |
| "S2L Association ID"; | | "S2L Association ID"; |
| } | | } |
| leaf s2l-association-source { | | leaf s2l-association-source { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "S2L Association Source"; | | "S2L Association Source"; |
| } | | } |
| leaf s2l-global-source { | | leaf s2l-global-source { |
| type uint32; | | type uint32; |
| description | | description |
| "S2L Global Source"; | | "S2L Global Source"; |
| } | | } |
| list s2l-extended-id { | | list s2l-extended-id { |
| description | | description |
| "S2L Extended ID Array"; | | "S2L Extended ID Array"; |
| leaf entry { | | leaf entry { |
| type uint32; | | type uint32; |
| description | | description |
| "S2L Extended ID Array"; | | "S2L Extended ID Array"; |
| } | | } |
| } | | } |
| } | | } |
| | | |
| grouping TE-S2L-SRLG-COLLECT-INFO { | | grouping TE-S2L-SRLG-COLLECT-INFO { |
| description | | description |
| "SRLG-collection information"; | | "SRLG-collection information"; |
| leaf srlg-collect-type { | | leaf srlg-collect-type { |
| type Te-srlg-collect-request; | | type Te-srlg-collect-request; |
| description | | description |
| "SRLG-collection mechanism"; | | "SRLG-collection mechanism"; |
| } | | } |
| list discovered-srlg { | | list discovered-srlg { |
| description | | description |
| "Discovered SRLGs"; | | "Discovered SRLGs"; |
| leaf entry { | | leaf entry { |
| type uint32; | | type uint32; |
| description | | description |
| "Discovered SRLGs"; | | "Discovered SRLGs"; |
| } | | } |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-TAIL-BFD-INFO { | | grouping MPLS-TE-TAIL-BFD-INFO { |
| description | | description |
| "TE Tail-end BFD information"; | | "TE Tail-end BFD information"; |
| container session-info { | | container session-info { |
| description | | description |
| "BFD Session Info"; | | "BFD Session Info"; |
| uses MPLS-TE-BFD-SESSION-INFO; | | uses MPLS-TE-BFD-SESSION-INFO; |
| } | | } |
| leaf failure-diagnostic-code { | | leaf failure-diagnostic-code { |
| type uint32; | | type uint32; |
| description | | description |
| "BFD session failure diagnostic code"; | | "BFD session failure diagnostic code"; |
| } | | } |
| leaf failure-reason { | | leaf failure-reason { |
| type string; | | type string; |
| description | | description |
| "BFD session failure reason"; | | "BFD session failure reason"; |
| } | | } |
| leaf local-discriminator { | | leaf local-discriminator { |
| type uint32; | | type uint32; |
| description | | description |
| "BFD Local Discriminator"; | | "BFD Local Discriminator"; |
| } | | } |
| leaf remote-discriminator { | | leaf remote-discriminator { |
| type uint32; | | type uint32; |
| description | | description |
| "BFD Remote Discrminator"; | | "BFD Remote Discrminator"; |
| } | | } |
| leaf min-interval { | | leaf min-interval { |
| type uint32; | | type uint32; |
| description | | description |
| "Hello interval in mini second"; | | "Hello interval in mini second"; |
| } | | } |
| leaf min-interval-default { | | leaf min-interval-default { |
| type boolean; | | type boolean; |
| description | | description |
| "Is default hello interval"; | | "Is default hello interval"; |
| } | | } |
| leaf multiplier { | | leaf multiplier { |
| type uint8; | | type uint8; |
| description | | description |
| "Multiplier"; | | "Multiplier"; |
| } | | } |
| leaf multiplier-default { | | leaf multiplier-default { |
| type boolean; | | type boolean; |
| description | | description |
| "Is default multiplier"; | | "Is default multiplier"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-BFD-DELETION-HISTORY { | | grouping MPLS-TE-BFD-DELETION-HISTORY { |
| description | | description |
| "TE Tunnel BFD Session Deletion History"; | | "TE Tunnel BFD Session Deletion History"; |
| leaf lsp-id { | | leaf lsp-id { |
| type uint16; | | type uint16; |
| description | | description |
| "LSP ID of the BFD session get deleted"; | | "LSP ID of the BFD session get deleted"; |
| } | | } |
| leaf deletion-time { | | leaf deletion-time { |
| type uint32; | | type uint32; |
| description | | description |
| "Time stamp of the BFD session get deleted"; | | "Time stamp of the BFD session get deleted"; |
| } | | } |
| leaf deletion-reason { | | leaf deletion-reason { |
| type string; | | type string; |
| description | | description |
| "Reason for the BFD session get deleted"; | | "Reason for the BFD session get deleted"; |
| } | | } |
| leaf deletion-diagnostic-code { | | leaf deletion-diagnostic-code { |
| type uint32; | | type uint32; |
| description | | description |
| "Diagnostic Code for the BFD session get deleted"; | | "Diagnostic Code for the BFD session get deleted"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-BFD-SESSION-INFO { | | grouping MPLS-TE-BFD-SESSION-INFO { |
| description | | description |
| "TE BFD Session Info"; | | "TE BFD Session Info"; |
| leaf state { | | leaf state { |
| type Te-bfd-lsp-session-state; | | type Te-bfd-lsp-session-state; |
| description | | description |
| "BFD session state"; | | "BFD session state"; |
| } | | } |
| leaf state-change-time { | | leaf state-change-time { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Time in seconds since the last session state | | "Time in seconds since the last session state |
| change"; | | change"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-HEAD-BFD-INFO { | | grouping MPLS-TE-HEAD-BFD-INFO { |
| description | | description |
| "TE Head-end BFD information"; | | "TE Head-end BFD information"; |
| container session-info { | | container session-info { |
| description | | description |
| "BFD Session Info"; | | "BFD Session Info"; |
| uses MPLS-TE-BFD-SESSION-INFO; | | uses MPLS-TE-BFD-SESSION-INFO; |
| } | | } |
| container deletion-history { | | container deletion-history { |
| description | | description |
| "BFD Session Deletion History"; | | "BFD Session Deletion History"; |
| uses MPLS-TE-BFD-DELETION-HISTORY; | | uses MPLS-TE-BFD-DELETION-HISTORY; |
| } | | } |
| leaf creation-time { | | leaf creation-time { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Time in seconds since the BFD session created"; | | "Time in seconds since the BFD session created"; |
| } | | } |
| leaf lspbfd-type { | | leaf lspbfd-type { |
| type Te-vif-bfd; | | type Te-vif-bfd; |
| description | | description |
| "LSP BFD type"; | | "LSP BFD type"; |
| } | | } |
| leaf is-redundant { | | leaf is-redundant { |
| type boolean; | | type boolean; |
| description | | description |
| "sBFD session is redundant"; | | "sBFD session is redundant"; |
| } | | } |
| leaf bfd-reverse-path-stale { | | leaf bfd-reverse-path-stale { |
| type boolean; | | type boolean; |
| description | | description |
| "The BFD reverse path is stale compared to | | "The BFD reverse path is stale compared to |
| configuration"; | | configuration"; |
| } | | } |
| list bfd-reverse-path-label { | | list bfd-reverse-path-label { |
| description | | description |
| "BFD reverse path labels"; | | "BFD reverse path labels"; |
| leaf entry { | | leaf entry { |
| type uint32; | | type uint32; |
| description | | description |
| "BFD reverse path labels"; | | "BFD reverse path labels"; |
| } | | } |
| } | | } |
| } | | } |
| | | |
| grouping TE-PVT-PROT-OBJ { | | grouping TE-PVT-PROT-OBJ { |
| description | | description |
| "Private Protection information signaled"; | | "Private Protection information signaled"; |
| leaf sbit { | | leaf sbit { |
| type boolean; | | type boolean; |
| description | | description |
| "Secondary bit"; | | "Secondary bit"; |
| } | | } |
| leaf pbit { | | leaf pbit { |
| type boolean; | | type boolean; |
| description | | description |
| "Protecting bit"; | | "Protecting bit"; |
| } | | } |
| leaf nbit { | | leaf nbit { |
| type boolean; | | type boolean; |
| description | | description |
| "Notification bit "; | | "Notification bit "; |
| } | | } |
| leaf obit { | | leaf obit { |
| type boolean; | | type boolean; |
| description | | description |
| "Operational bit"; | | "Operational bit"; |
| } | | } |
| leaf protect-type { | | leaf protect-type { |
| type Te-protect; | | type Te-protect; |
| description | | description |
| "LSP Protect Type"; | | "LSP Protect Type"; |
| } | | } |
| leaf is-wtr-present { | | leaf is-wtr-present { |
| type boolean; | | type boolean; |
| description | | description |
| "Is Wait-to-Restore timeout present"; | | "Is Wait-to-Restore timeout present"; |
| } | | } |
| leaf wtr-timeout { | | leaf wtr-timeout { |
| type uint32; | | type uint32; |
| description | | description |
| "Wait-to-Restore timeout"; | | "Wait-to-Restore timeout"; |
| } | | } |
| leaf is-hopresent { | | leaf is-hopresent { |
| type boolean; | | type boolean; |
| description | | description |
| "Is Hold-Off timeout present"; | | "Is Hold-Off timeout present"; |
| } | | } |
| leaf ho-timeout { | | leaf ho-timeout { |
| type uint32; | | type uint32; |
| description | | description |
| "Hold-Off timeout"; | | "Hold-Off timeout"; |
| } | | } |
| leaf is-snc-mode-present { | | leaf is-snc-mode-present { |
| type boolean; | | type boolean; |
| description | | description |
| "Is SNC mode present"; | | "Is SNC mode present"; |
| } | | } |
| leaf snc-mode { | | leaf snc-mode { |
| type Te-aps-snc-mode; | | type Te-aps-snc-mode; |
| description | | description |
| "SNC mode"; | | "SNC mode"; |
| } | | } |
| leaf tcm-id { | | leaf tcm-id { |
| type uint32; | | type uint32; |
| description | | description |
| "TCM ID"; | | "TCM ID"; |
| } | | } |
| leaf path-prot-profile-type { | | leaf path-prot-profile-type { |
| type Te-path-prot-profile; | | type Te-path-prot-profile; |
| description | | description |
| "Path protection profile type"; | | "Path protection profile type"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-S2L-APS-INFO { | | grouping MPLS-TE-S2L-APS-INFO { |
| description | | description |
| "APS Protection Info of S2L"; | | "APS Protection Info of S2L"; |
| container protection-info { | | container protection-info { |
| description | | description |
| "Protection Info"; | | "Protection Info"; |
| uses TE-PVT-PROT-OBJ; | | uses TE-PVT-PROT-OBJ; |
| } | | } |
| } | | } |
| | | |
| grouping TE-ODU-FLEX-GFP-F-NON-RES-INFO { | | grouping TE-ODU-FLEX-GFP-F-NON-RES-INFO { |
| description | | description |
| "ODU flex info for non-resizable GFP-F framing | | "ODU flex info for non-resizable GFP-F framing |
| type"; | | type"; |
| leaf bit-rate { | | leaf bit-rate { |
| type uint32; | | type uint32; |
| description | | description |
| "Bit rate in kbit/s"; | | "Bit rate in kbit/s"; |
| } | | } |
| } | | } |
| | | |
| grouping TE-ODU-FLEX-GFP-F-RES-INFO { | | grouping TE-ODU-FLEX-GFP-F-RES-INFO { |
| description | | description |
| "ODU flex info for resizable GFP-F framing type"; | | "ODU flex info for resizable GFP-F framing type"; |
| leaf bit-rate { | | leaf bit-rate { |
| type uint32; | | type uint32; |
| description | | description |
| "Bit rate in kbit/s"; | | "Bit rate in kbit/s"; |
| } | | } |
| } | | } |
| | | |
| grouping TE-ODU-FLEX-CBR-INFO { | | grouping TE-ODU-FLEX-CBR-INFO { |
| description | | description |
| "ODU flex info for CBR framing type"; | | "ODU flex info for CBR framing type"; |
| leaf bit-rate { | | leaf bit-rate { |
| type uint32; | | type uint32; |
| description | | description |
| "Bit rate in kbit/s"; | | "Bit rate in kbit/s"; |
| } | | } |
| leaf tolerance { | | leaf tolerance { |
| type uint16; | | type uint16; |
| description | | description |
| "Tolerance"; | | "Tolerance"; |
| } | | } |
| } | | } |
| | | |
| grouping TE-ODU-V3-BW { | | grouping TE-ODU-V3-BW { |
| description | | description |
| "ODU bandwidth union"; | | "ODU bandwidth union"; |
| container odu-flex-cbr { | | container odu-flex-cbr { |
| when "../odu-level = 'te-odu-level-flex-cbr'" { | | when "../odu-level = 'te-odu-level-flex-cbr'" { |
| description | | description |
| "../ODULevel = 'TE_ODULevelFlexCBR'"; | | "../ODULevel = 'TE_ODULevelFlexCBR'"; |
| } | | } |
| description | | description |
| "Odu flex CBR info"; | | "Odu flex CBR info"; |
| uses TE-ODU-FLEX-CBR-INFO; | | uses TE-ODU-FLEX-CBR-INFO; |
| } | | } |
| container odu-flex-gfp-f-res { | | container odu-flex-gfp-f-res { |
| when "../odu-level = 'te-odu-level-flex-gfpf-resizeable'" { | | when "../odu-level = 'te-odu-level-flex-gfpf-resizeable'" { |
| description | | description |
| "../ODULevel = 'TE_ODULevelFlexGFPFResizeable'"; | | "../ODULevel = 'TE_ODULevelFlexGFPFResizeable'"; |
| } | | } |
| description | | description |
| "Odu flex GFP-F resizable info"; | | "Odu flex GFP-F resizable info"; |
| uses TE-ODU-FLEX-GFP-F-RES-INFO; | | uses TE-ODU-FLEX-GFP-F-RES-INFO; |
| } | | } |
| container odu-flex-gfp-f-non-res { | | container odu-flex-gfp-f-non-res { |
| when "../odu-level = 'te-odu-level-flex-gfpf-non-resizable'" { | | when "../odu-level = 'te-odu-level-flex-gfpf-non-resizable'" { |
| description | | description |
| "../ODULevel = 'TE_ODULevelFlexGFPFNonResizable'"; | | "../ODULevel = 'TE_ODULevelFlexGFPFNonResizable'"; |
| } | | } |
| description | | description |
| "Odu flex GFP-F non-resizable info"; | | "Odu flex GFP-F non-resizable info"; |
| uses TE-ODU-FLEX-GFP-F-NON-RES-INFO; | | uses TE-ODU-FLEX-GFP-F-NON-RES-INFO; |
| } | | } |
| leaf odu-level { | | leaf odu-level { |
| type Te-odu-level; | | type Te-odu-level; |
| description | | description |
| "ODULevel"; | | "ODULevel"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-S2L-OTN-INFO { | | grouping MPLS-TE-S2L-OTN-INFO { |
| description | | description |
| "OTN S2L's Controllers' information"; | | "OTN S2L's Controllers' information"; |
| container bandwidth { | | container bandwidth { |
| description | | description |
| "OTN Bandwidth for s2l"; | | "OTN Bandwidth for s2l"; |
| uses TE-ODU-V3-BW; | | uses TE-ODU-V3-BW; |
| } | | } |
| container labels { | | container labels { |
| description | | description |
| "Labels"; | | "Labels"; |
| uses MPLS-TE-MGMT-GMPLS-LABELS; | | uses MPLS-TE-MGMT-GMPLS-LABELS; |
| } | | } |
| leaf incoming-controller { | | leaf incoming-controller { |
| type string; | | type string; |
| description | | description |
| "Incoming Controller"; | | "Incoming Controller"; |
| } | | } |
| leaf incoming-controller-state { | | leaf incoming-controller-state { |
| type Te-controller-state; | | type Te-controller-state; |
| description | | description |
| "State of Incoming Controller"; | | "State of Incoming Controller"; |
| } | | } |
| leaf incoming-sub-controller { | | leaf incoming-sub-controller { |
| type string; | | type string; |
| description | | description |
| "Incoming Sub Controller"; | | "Incoming Sub Controller"; |
| } | | } |
| leaf incoming-sub-controller-state { | | leaf incoming-sub-controller-state { |
| type Te-controller-state; | | type Te-controller-state; |
| description | | description |
| "State of Incoming Sub Controller"; | | "State of Incoming Sub Controller"; |
| } | | } |
| leaf outgoing-controller { | | leaf outgoing-controller { |
| type string; | | type string; |
| description | | description |
| "Outgoing Controller"; | | "Outgoing Controller"; |
| } | | } |
| leaf outgoing-controller-state { | | leaf outgoing-controller-state { |
| type Te-controller-state; | | type Te-controller-state; |
| description | | description |
| "State of Outgoing Controller"; | | "State of Outgoing Controller"; |
| } | | } |
| leaf outgoing-sub-controller { | | leaf outgoing-sub-controller { |
| type string; | | type string; |
| description | | description |
| "Outgoing Sub Controller"; | | "Outgoing Sub Controller"; |
| } | | } |
| leaf outgoing-sub-controller-state { | | leaf outgoing-sub-controller-state { |
| type Te-controller-state; | | type Te-controller-state; |
| description | | description |
| "State of Outgoing Sub Controller"; | | "State of Outgoing Sub Controller"; |
| } | | } |
| leaf cross-connect-id { | | leaf cross-connect-id { |
| type uint32; | | type uint32; |
| description | | description |
| "Cross connect id"; | | "Cross connect id"; |
| } | | } |
| leaf is-connected { | | leaf is-connected { |
| type boolean; | | type boolean; |
| description | | description |
| "True if subcontrollers are connected"; | | "True if subcontrollers are connected"; |
| } | | } |
| leaf uptime { | | leaf uptime { |
| type uint32; | | type uint32; |
| description | | description |
| "XC Uptime"; | | "XC Uptime"; |
| } | | } |
| leaf outgoing-controller-ifhandle { | | leaf outgoing-controller-ifhandle { |
| type xr:Interface-name; | | type xr:Interface-name; |
| description | | description |
| "Outgoing Controller Ifhandle"; | | "Outgoing Controller Ifhandle"; |
| } | | } |
| leaf outgoing-sub-controller-ifhandle { | | leaf outgoing-sub-controller-ifhandle { |
| type xr:Interface-name; | | type xr:Interface-name; |
| description | | description |
| "Outgoing Sub Controller Ifhandle"; | | "Outgoing Sub Controller Ifhandle"; |
| } | | } |
| leaf incoming-controller-ifhandle { | | leaf incoming-controller-ifhandle { |
| type xr:Interface-name; | | type xr:Interface-name; |
| description | | description |
| "Incoming Controller Ifhandle"; | | "Incoming Controller Ifhandle"; |
| } | | } |
| leaf incoming-sub-controller-ifhandle { | | leaf incoming-sub-controller-ifhandle { |
| type xr:Interface-name; | | type xr:Interface-name; |
| description | | description |
| "Incoming Sub Controller Ifhandle"; | | "Incoming Sub Controller Ifhandle"; |
| } | | } |
| leaf gpid { | | leaf gpid { |
| type uint16; | | type uint16; |
| description | | description |
| "Gpid Payload"; | | "Gpid Payload"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-OTN-S2L-INFO { | | grouping MPLS-TE-OTN-S2L-INFO { |
| description | | description |
| "OTN S2l information"; | | "OTN S2l information"; |
| container otn { | | container otn { |
| description | | description |
| "Info Related to OTN technology in S2L"; | | "Info Related to OTN technology in S2L"; |
| uses MPLS-TE-S2L-OTN-INFO; | | uses MPLS-TE-S2L-OTN-INFO; |
| } | | } |
| container aps { | | container aps { |
| description | | description |
| "APS Info for OTN S2L"; | | "APS Info for OTN S2L"; |
| uses MPLS-TE-S2L-APS-INFO; | | uses MPLS-TE-S2L-APS-INFO; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-MGMT-FSC-LABEL { | | grouping MPLS-TE-MGMT-FSC-LABEL { |
| description | | description |
| "GMPLS FSC Label"; | | "GMPLS FSC Label"; |
| leaf interface-id { | | leaf interface-id { |
| type uint32; | | type uint32; |
| description | | description |
| "Interface Identifier"; | | "Interface Identifier"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-MGMT-G709-OTN-FIXED-SIZE-LABEL { | | grouping MPLS-TE-MGMT-G709-OTN-FIXED-SIZE-LABEL { |
| description | | description |
| "GMPLS G709 OTN fixed-size Label"; | | "GMPLS G709 OTN fixed-size Label"; |
| leaf tpn { | | leaf tpn { |
| type uint16; | | type uint16; |
| description | | description |
| "Tributary time slot"; | | "Tributary time slot"; |
| } | | } |
| leaf bit-map-length { | | leaf bit-map-length { |
| type uint16; | | type uint16; |
| description | | description |
| "Bit map length"; | | "Bit map length"; |
| } | | } |
| list bit-map { | | list bit-map { |
| description | | description |
| "Bit Map"; | | "Bit Map"; |
| leaf entry { | | leaf entry { |
| type uint8; | | type uint8; |
| description | | description |
| "Bit Map"; | | "Bit Map"; |
| } | | } |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-MGMT-WDM-FIXED-GRID-LABEL { | | grouping MPLS-TE-MGMT-WDM-FIXED-GRID-LABEL { |
| description | | description |
| "GMPLS WDM fixed-grid Label"; | | "GMPLS WDM fixed-grid Label"; |
| leaf label-set { | | leaf label-set { |
| type boolean; | | type boolean; |
| description | | description |
| "Flag to indicate whether label is set"; | | "Flag to indicate whether label is set"; |
| } | | } |
| leaf grid { | | leaf grid { |
| type Gmpls-uni-mgmt-wdm-grid; | | type Gmpls-uni-mgmt-wdm-grid; |
| description | | description |
| "Grid"; | | "Grid"; |
| } | | } |
| leaf channel-spacing { | | leaf channel-spacing { |
| type Gmpls-uni-mgmt-dwdm-cs; | | type Gmpls-uni-mgmt-dwdm-cs; |
| description | | description |
| "Channel spacing"; | | "Channel spacing"; |
| } | | } |
| leaf identifier { | | leaf identifier { |
| type uint16; | | type uint16; |
| description | | description |
| "Identifier"; | | "Identifier"; |
| } | | } |
| leaf channel { | | leaf channel { |
| type int16; | | type int16; |
| description | | description |
| "Channel Number"; | | "Channel Number"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-MGMT-GMPLS-LABEL { | | grouping MPLS-TE-MGMT-GMPLS-LABEL { |
| description | | description |
| "A GMPLS label"; | | "A GMPLS label"; |
| container wdm { | | container wdm { |
| when "../label-type = 'fixed-wdm'" { | | when "../label-type = 'fixed-wdm'" { |
| description | | description |
| "../LabelType = 'FixedWDM'"; | | "../LabelType = 'FixedWDM'"; |
| } | | } |
| description | | description |
| "Fixed-grid WDM label"; | | "Fixed-grid WDM label"; |
| uses MPLS-TE-MGMT-WDM-FIXED-GRID-LABEL; | | uses MPLS-TE-MGMT-WDM-FIXED-GRID-LABEL; |
| } | | } |
| container otn { | | container otn { |
| when "../label-type = 'fixed-g709otn'" { | | when "../label-type = 'fixed-g709otn'" { |
| description | | description |
| "../LabelType = 'FixedG709OTN'"; | | "../LabelType = 'FixedG709OTN'"; |
| } | | } |
| description | | description |
| "Fixed-size G09 OTN label"; | | "Fixed-size G09 OTN label"; |
| uses MPLS-TE-MGMT-G709-OTN-FIXED-SIZE-LABEL; | | uses MPLS-TE-MGMT-G709-OTN-FIXED-SIZE-LABEL; |
| } | | } |
| container fsc { | | container fsc { |
| when "../label-type = 'fsc'" { | | when "../label-type = 'fsc'" { |
| description | | description |
| "../LabelType = 'FSC'"; | | "../LabelType = 'FSC'"; |
| } | | } |
| description | | description |
| "FSC label"; | | "FSC label"; |
| uses MPLS-TE-MGMT-FSC-LABEL; | | uses MPLS-TE-MGMT-FSC-LABEL; |
| } | | } |
| leaf label-type { | | leaf label-type { |
| type Mpls-te-mgmt-gmpls-label; | | type Mpls-te-mgmt-gmpls-label; |
| description | | description |
| "LabelType"; | | "LabelType"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-MGMT-GMPLS-LABELS { | | grouping MPLS-TE-MGMT-GMPLS-LABELS { |
| description | | description |
| "GMPLS Labels"; | | "GMPLS Labels"; |
| container path-ingress-label { | | container path-ingress-label { |
| description | | description |
| "Path message (upstream) ingress label"; | | "Path message (upstream) ingress label"; |
| uses MPLS-TE-MGMT-GMPLS-LABEL; | | uses MPLS-TE-MGMT-GMPLS-LABEL; |
| } | | } |
| container path-egress-label { | | container path-egress-label { |
| description | | description |
| "Path message (upstream) egress label"; | | "Path message (upstream) egress label"; |
| uses MPLS-TE-MGMT-GMPLS-LABEL; | | uses MPLS-TE-MGMT-GMPLS-LABEL; |
| } | | } |
| container resv-ingress-label { | | container resv-ingress-label { |
| description | | description |
| "Resv message (downstream) ingress label"; | | "Resv message (downstream) ingress label"; |
| uses MPLS-TE-MGMT-GMPLS-LABEL; | | uses MPLS-TE-MGMT-GMPLS-LABEL; |
| } | | } |
| container resv-egress-label { | | container resv-egress-label { |
| description | | description |
| "Resv message (downstream) egress label"; | | "Resv message (downstream) egress label"; |
| uses MPLS-TE-MGMT-GMPLS-LABEL; | | uses MPLS-TE-MGMT-GMPLS-LABEL; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-SOFT-PREEMPTION-LSP-INFO { | | grouping MPLS-TE-SOFT-PREEMPTION-LSP-INFO { |
| description | | description |
| "Midpoint Soft Preemption LSP Info"; | | "Midpoint Soft Preemption LSP Info"; |
| leaf status { | | leaf status { |
| type Mpls-te-soft-preemption-state; | | type Mpls-te-soft-preemption-state; |
| description | | description |
| "The current state of the soft preemption | | "The current state of the soft preemption |
| operation"; | | operation"; |
| } | | } |
| leaf soft-preemption-timestamp { | | leaf soft-preemption-timestamp { |
| type uint32; | | type uint32; |
| description | | description |
| "The POSIX timestamp when the soft preemption | | "The POSIX timestamp when the soft preemption |
| occurred"; | | occurred"; |
| } | | } |
| leaf soft-preemption-link { | | leaf soft-preemption-link { |
| type string; | | type string; |
| description | | description |
| "Name of the link where the soft preemption | | "Name of the link where the soft preemption |
| occurred"; | | occurred"; |
| } | | } |
| leaf preempting-link-address { | | leaf preempting-link-address { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "The address of the link where the preemption | | "The address of the link where the preemption |
| happened"; | | happened"; |
| } | | } |
| leaf time-to-hard-preemption { | | leaf time-to-hard-preemption { |
| type uint16; | | type uint16; |
| units "second"; | | units "second"; |
| description | | description |
| "The number of seconds until hard preemption is | | "The number of seconds until hard preemption is |
| triggered"; | | triggered"; |
| } | | } |
| leaf fr-rrewrite { | | leaf fr-rrewrite { |
| type boolean; | | type boolean; |
| description | | description |
| "FRR-rewrite during soft preemption"; | | "FRR-rewrite during soft preemption"; |
| } | | } |
| leaf fr-rrewrite-tunnel-name { | | leaf fr-rrewrite-tunnel-name { |
| type string; | | type string; |
| description | | description |
| "The tunnel name of the backup"; | | "The tunnel name of the backup"; |
| } | | } |
| } | | } |
| | | |
| grouping TE-LSP-CONVERGENCE-INFO { | | grouping TE-LSP-CONVERGENCE-INFO { |
| description | | description |
| "TE LSP convergence related information"; | | "TE LSP convergence related information"; |
| leaf path-in { | | leaf path-in { |
| type uint64; | | type uint64; |
| units "nanosecond"; | | units "nanosecond"; |
| description | | description |
| "LSP RSVP Path-in timestamp (clocktime in nsecs)"; | | "LSP RSVP Path-in timestamp (clocktime in nsecs)"; |
| } | | } |
| leaf path-out { | | leaf path-out { |
| type uint64; | | type uint64; |
| units "nanosecond"; | | units "nanosecond"; |
| description | | description |
| "LSP RSVP Path-in timestamp (clocktime in nsecs)"; | | "LSP RSVP Path-in timestamp (clocktime in nsecs)"; |
| } | | } |
| leaf resv-in { | | leaf resv-in { |
| type uint64; | | type uint64; |
| units "nanosecond"; | | units "nanosecond"; |
| description | | description |
| "LSP RSVP Resv-in timestamp (clocktime in nsecs)"; | | "LSP RSVP Resv-in timestamp (clocktime in nsecs)"; |
| } | | } |
| leaf resv-out { | | leaf resv-out { |
| type uint64; | | type uint64; |
| units "nanosecond"; | | units "nanosecond"; |
| description | | description |
| "LSP RSVP Resv-out timestamp (clocktime in nsecs)"; | | "LSP RSVP Resv-out timestamp (clocktime in nsecs)"; |
| } | | } |
| leaf label-rewrite { | | leaf label-rewrite { |
| type uint64; | | type uint64; |
| units "nanosecond"; | | units "nanosecond"; |
| description | | description |
| "LSP Label rewrite timestamp (clocktime in nsecs)"; | | "LSP Label rewrite timestamp (clocktime in nsecs)"; |
| } | | } |
| leaf tunnel-rewrite { | | leaf tunnel-rewrite { |
| type uint64; | | type uint64; |
| units "nanosecond"; | | units "nanosecond"; |
| description | | description |
| "Tunnel rewrite timestamp (clocktime in nsecs)"; | | "Tunnel rewrite timestamp (clocktime in nsecs)"; |
| } | | } |
| leaf creation-time { | | leaf creation-time { |
| type uint64; | | type uint64; |
| units "nanosecond"; | | units "nanosecond"; |
| description | | description |
| "Tunnel creation timestamp (clocktime in nsecs)"; | | "Tunnel creation timestamp (clocktime in nsecs)"; |
| } | | } |
| } | | } |
| | | |
| grouping TE-MGMT-G709-OTN-FSPEC { | | grouping TE-MGMT-G709-OTN-FSPEC { |
| description | | description |
| "TE G709 OTN FSpec"; | | "TE G709 OTN FSpec"; |
| leaf signal-type { | | leaf signal-type { |
| type uint8; | | type uint8; |
| description | | description |
| "Signal Type"; | | "Signal Type"; |
| } | | } |
| leaf nmc-or-tolerance { | | leaf nmc-or-tolerance { |
| type uint16; | | type uint16; |
| description | | description |
| "NMC or Tolerance"; | | "NMC or Tolerance"; |
| } | | } |
| leaf nvc { | | leaf nvc { |
| type uint16; | | type uint16; |
| description | | description |
| "Number of Virtual Components"; | | "Number of Virtual Components"; |
| } | | } |
| leaf multiplier { | | leaf multiplier { |
| type uint16; | | type uint16; |
| description | | description |
| "Multiplier"; | | "Multiplier"; |
| } | | } |
| leaf bit-rate { | | leaf bit-rate { |
| type uint32; | | type uint32; |
| units "kbit/s"; | | units "kbit/s"; |
| description | | description |
| "Bit Rate in kbps"; | | "Bit Rate in kbps"; |
| } | | } |
| } | | } |
| | | |
| grouping TE-MGMT-GENERIC-FSPEC { | | grouping TE-MGMT-GENERIC-FSPEC { |
| description | | description |
| "Union of different TE generic FSpec types"; | | "Union of different TE generic FSpec types"; |
| container otnfspec { | | container otnfspec { |
| when "../fspec-type = 'te-generic-fspec-type-g709otn'" { | | when "../fspec-type = 'te-generic-fspec-type-g709otn'" { |
| description | | description |
| "../FSpecType = 'TEGenericFSpecTypeG709OTN'"; | | "../FSpecType = 'TEGenericFSpecTypeG709OTN'"; |
| } | | } |
| description | | description |
| "TE FSpec for G709 OTN"; | | "TE FSpec for G709 OTN"; |
| uses TE-MGMT-G709-OTN-FSPEC; | | uses TE-MGMT-G709-OTN-FSPEC; |
| } | | } |
| leaf fspec-type { | | leaf fspec-type { |
| type Te-mgmt-generic-fspec; | | type Te-mgmt-generic-fspec; |
| description | | description |
| "FSpecType"; | | "FSpecType"; |
| } | | } |
| } | | } |
| | | |
| grouping TE-MGMT-G709-OTN-TSPEC { | | grouping TE-MGMT-G709-OTN-TSPEC { |
| description | | description |
| "TE G709 OTN TSpec"; | | "TE G709 OTN TSpec"; |
| leaf signal-type { | | leaf signal-type { |
| type uint8; | | type uint8; |
| description | | description |
| "Signal Type"; | | "Signal Type"; |
| } | | } |
| leaf nmc-or-tolerance { | | leaf nmc-or-tolerance { |
| type uint16; | | type uint16; |
| description | | description |
| "NMC or Tolerance"; | | "NMC or Tolerance"; |
| } | | } |
| leaf nvc { | | leaf nvc { |
| type uint16; | | type uint16; |
| description | | description |
| "Number of Virtual Components"; | | "Number of Virtual Components"; |
| } | | } |
| leaf multiplier { | | leaf multiplier { |
| type uint16; | | type uint16; |
| description | | description |
| "Multiplier"; | | "Multiplier"; |
| } | | } |
| leaf bit-rate { | | leaf bit-rate { |
| type uint32; | | type uint32; |
| units "kbit/s"; | | units "kbit/s"; |
| description | | description |
| "Bit Rate in kbps"; | | "Bit Rate in kbps"; |
| } | | } |
| } | | } |
| | | |
| grouping TE-MGMT-GENERIC-TSPEC { | | grouping TE-MGMT-GENERIC-TSPEC { |
| description | | description |
| "Union of different TE generic TSpec types"; | | "Union of different TE generic TSpec types"; |
| container otntspec { | | container otntspec { |
| when "../tspec-type = 'te-generic-tspec-type-g709otn'" { | | when "../tspec-type = 'te-generic-tspec-type-g709otn'" { |
| description | | description |
| "../TSpecType = 'TEGenericTSpecTypeG709OTN'"; | | "../TSpecType = 'TEGenericTSpecTypeG709OTN'"; |
| } | | } |
| description | | description |
| "TE TSpec for G709 OTN"; | | "TE TSpec for G709 OTN"; |
| uses TE-MGMT-G709-OTN-TSPEC; | | uses TE-MGMT-G709-OTN-TSPEC; |
| } | | } |
| leaf tspec-type { | | leaf tspec-type { |
| type Te-mgmt-generic-tspec; | | type Te-mgmt-generic-tspec; |
| description | | description |
| "TSpecType"; | | "TSpecType"; |
| } | | } |
| } | | } |
| | | |
| grouping BANDWIDTH-SPEC-BAG { | | grouping BANDWIDTH-SPEC-BAG { |
| description | | description |
| "Bandwidth information of a flow"; | | "Bandwidth information of a flow"; |
| leaf average-rate { | | leaf average-rate { |
| type uint64; | | type uint64; |
| units "kbit/s"; | | units "kbit/s"; |
| description | | description |
| "Average bandwidth in kbps"; | | "Average bandwidth in kbps"; |
| } | | } |
| leaf maximum-burst { | | leaf maximum-burst { |
| type uint64; | | type uint64; |
| units "byte"; | | units "byte"; |
| description | | description |
| "Maximum burst of data in bytes"; | | "Maximum burst of data in bytes"; |
| } | | } |
| leaf peak-rate { | | leaf peak-rate { |
| type uint64; | | type uint64; |
| units "kbit/s"; | | units "kbit/s"; |
| description | | description |
| "Peak rate in kbps"; | | "Peak rate in kbps"; |
| } | | } |
| } | | } |
| | | |
| grouping TUNNEL-HOP-INFO { | | grouping TUNNEL-HOP-INFO { |
| description | | description |
| "Hop information"; | | "Hop information"; |
| leaf hop-address { | | leaf hop-address { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Hop address"; | | "Hop address"; |
| } | | } |
| leaf hop-affinity { | | leaf hop-affinity { |
| type uint32; | | type uint32; |
| description | | description |
| "Deprecated"; | | "Deprecated"; |
| } | | } |
| list hop-extended-affinity { | | list hop-extended-affinity { |
| description | | description |
| "Hop affinity"; | | "Hop affinity"; |
| leaf entry { | | leaf entry { |
| type uint32; | | type uint32; |
| description | | description |
| "Hop affinity"; | | "Hop affinity"; |
| } | | } |
| } | | } |
| } | | } |
| | | |
| grouping RSVP-MGMT-RRO-SRLG-SUBOBJ { | | grouping RSVP-MGMT-RRO-SRLG-SUBOBJ { |
| description | | description |
| "RSVP RRO SRLG subobject"; | | "RSVP RRO SRLG subobject"; |
| list srl-gs { | | list srl-gs { |
| description | | description |
| "The RRO Subobject SRLGs"; | | "The RRO Subobject SRLGs"; |
| leaf entry { | | leaf entry { |
| type uint32; | | type uint32; |
| description | | description |
| "The RRO Subobject SRLGs"; | | "The RRO Subobject SRLGs"; |
| } | | } |
| } | | } |
| } | | } |
| | | |
| grouping RSVP-MGMT-RRO-UNNUMBERED-SUBOBJ-FLAGS { | | grouping RSVP-MGMT-RRO-UNNUMBERED-SUBOBJ-FLAGS { |
| description | | description |
| "RSVP RRO UNNUMBERED Subobject Flags"; | | "RSVP RRO UNNUMBERED Subobject Flags"; |
| leaf is-protection-available { | | leaf is-protection-available { |
| type boolean; | | type boolean; |
| description | | description |
| "Local Protection Available"; | | "Local Protection Available"; |
| } | | } |
| leaf is-protection-in-use { | | leaf is-protection-in-use { |
| type boolean; | | type boolean; |
| description | | description |
| "Local Protection In Use"; | | "Local Protection In Use"; |
| } | | } |
| leaf is-bandwidth-protected { | | leaf is-bandwidth-protected { |
| type boolean; | | type boolean; |
| description | | description |
| "Bandwidth Protection Available"; | | "Bandwidth Protection Available"; |
| } | | } |
| leaf is-node-protection-available { | | leaf is-node-protection-available { |
| type boolean; | | type boolean; |
| description | | description |
| "Node Protection Available"; | | "Node Protection Available"; |
| } | | } |
| leaf is-node-id { | | leaf is-node-id { |
| type boolean; | | type boolean; |
| description | | description |
| "Node ID In Use"; | | "Node ID In Use"; |
| } | | } |
| } | | } |
| | | |
| grouping RSVP-MGMT-RRO-UNNUMBERED-SUBOBJ { | | grouping RSVP-MGMT-RRO-UNNUMBERED-SUBOBJ { |
| description | | description |
| "RSVP RRO Unnumbered subobject"; | | "RSVP RRO Unnumbered subobject"; |
| container flags { | | container flags { |
| description | | description |
| "The RRO Subobject Unnumbered Flags"; | | "The RRO Subobject Unnumbered Flags"; |
| uses RSVP-MGMT-RRO-UNNUMBERED-SUBOBJ-FLAGS; | | uses RSVP-MGMT-RRO-UNNUMBERED-SUBOBJ-FLAGS; |
| } | | } |
| leaf interface-address { | | leaf interface-address { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "The RRO Interface Address"; | | "The RRO Interface Address"; |
| } | | } |
| leaf interface-id { | | leaf interface-id { |
| type uint32; | | type uint32; |
| description | | description |
| "The RRO Interface ID"; | | "The RRO Interface ID"; |
| } | | } |
| } | | } |
| | | |
| grouping RSVP-MGMT-RRO-LABEL-SUBOBJ-FLAGS { | | grouping RSVP-MGMT-RRO-LABEL-SUBOBJ-FLAGS { |
| description | | description |
| "RSVP RRO Label Subobject Flags"; | | "RSVP RRO Label Subobject Flags"; |
| leaf is-global-label { | | leaf is-global-label { |
| type boolean; | | type boolean; |
| description | | description |
| "Label is Global across all interfaces"; | | "Label is Global across all interfaces"; |
| } | | } |
| } | | } |
| | | |
| grouping RSVP-MGMT-RRO-LABEL-SUBOBJ { | | grouping RSVP-MGMT-RRO-LABEL-SUBOBJ { |
| description | | description |
| "RSVP RRO Label subobject"; | | "RSVP RRO Label subobject"; |
| container flags { | | container flags { |
| description | | description |
| "The RRO Subobject Label Flags"; | | "The RRO Subobject Label Flags"; |
| uses RSVP-MGMT-RRO-LABEL-SUBOBJ-FLAGS; | | uses RSVP-MGMT-RRO-LABEL-SUBOBJ-FLAGS; |
| } | | } |
| leaf label { | | leaf label { |
| type uint32; | | type uint32; |
| description | | description |
| "The RRO Subobject Label Value"; | | "The RRO Subobject Label Value"; |
| } | | } |
| leaf is-label-variable-length { | | leaf is-label-variable-length { |
| type boolean; | | type boolean; |
| description | | description |
| "Is the RRO Subobject Label Variable Length"; | | "Is the RRO Subobject Label Variable Length"; |
| } | | } |
| list variable-length-label { | | list variable-length-label { |
| description | | description |
| "The RRO Subobject Variable Length Label"; | | "The RRO Subobject Variable Length Label"; |
| leaf entry { | | leaf entry { |
| type uint32; | | type uint32; |
| description | | description |
| "The RRO Subobject Variable Length Label"; | | "The RRO Subobject Variable Length Label"; |
| } | | } |
| } | | } |
| } | | } |
| | | |
| grouping RSVP-MGMT-RRO-IPV4-SUBOBJ-FLAGS { | | grouping RSVP-MGMT-RRO-IPV4-SUBOBJ-FLAGS { |
| description | | description |
| "RSVP RRO IPV4 Subobject Flags"; | | "RSVP RRO IPV4 Subobject Flags"; |
| leaf is-protection-available { | | leaf is-protection-available { |
| type boolean; | | type boolean; |
| description | | description |
| "Local Protection Available"; | | "Local Protection Available"; |
| } | | } |
| leaf is-protection-in-use { | | leaf is-protection-in-use { |
| type boolean; | | type boolean; |
| description | | description |
| "Local Protection In Use"; | | "Local Protection In Use"; |
| } | | } |
| leaf is-bandwidth-protected { | | leaf is-bandwidth-protected { |
| type boolean; | | type boolean; |
| description | | description |
| "Bandwidth Protection Available"; | | "Bandwidth Protection Available"; |
| } | | } |
| leaf is-node-protection-available { | | leaf is-node-protection-available { |
| type boolean; | | type boolean; |
| description | | description |
| "Node Protection Available"; | | "Node Protection Available"; |
| } | | } |
| leaf is-node-id { | | leaf is-node-id { |
| type boolean; | | type boolean; |
| description | | description |
| "Node ID In Use"; | | "Node ID In Use"; |
| } | | } |
| } | | } |
| | | |
| grouping RSVP-MGMT-RRO-IPV4-SUBOBJ { | | grouping RSVP-MGMT-RRO-IPV4-SUBOBJ { |
| description | | description |
| "RSVP RRO IPV4 subobject"; | | "RSVP RRO IPV4 subobject"; |
| container flags { | | container flags { |
| description | | description |
| "The RRO IPV4 Subobject Flags"; | | "The RRO IPV4 Subobject Flags"; |
| uses RSVP-MGMT-RRO-IPV4-SUBOBJ-FLAGS; | | uses RSVP-MGMT-RRO-IPV4-SUBOBJ-FLAGS; |
| } | | } |
| leaf rro-address { | | leaf rro-address { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "The RRO IPV4 Address"; | | "The RRO IPV4 Address"; |
| } | | } |
| } | | } |
| | | |
| grouping RSVP-MGMT-RRO-SUBOBJ { | | grouping RSVP-MGMT-RRO-SUBOBJ { |
| description | | description |
| "Union of the different RSVP RRO types"; | | "Union of the different RSVP RRO types"; |
| container ipv4rro-sub-object { | | container ipv4rro-sub-object { |
| when "../rro-type = 'ipv4rro-type'" { | | when "../rro-type = 'ipv4rro-type'" { |
| description | | description |
| "../RROType = 'IPv4RROType'"; | | "../RROType = 'IPv4RROType'"; |
| } | | } |
| description | | description |
| "IPV4 RRO Sub Object"; | | "IPV4 RRO Sub Object"; |
| uses RSVP-MGMT-RRO-IPV4-SUBOBJ; | | uses RSVP-MGMT-RRO-IPV4-SUBOBJ; |
| } | | } |
| container label-rro-sub-object { | | container label-rro-sub-object { |
| when "../rro-type = 'label-rro-type'" { | | when "../rro-type = 'label-rro-type'" { |
| description | | description |
| "../RROType = 'LabelRROType'"; | | "../RROType = 'LabelRROType'"; |
| } | | } |
| description | | description |
| "Label RRO Sub Object"; | | "Label RRO Sub Object"; |
| uses RSVP-MGMT-RRO-LABEL-SUBOBJ; | | uses RSVP-MGMT-RRO-LABEL-SUBOBJ; |
| } | | } |
| container unnumbered-rro-sub-object { | | container unnumbered-rro-sub-object { |
| when "../rro-type = 'unnumbered-rro-type'" { | | when "../rro-type = 'unnumbered-rro-type'" { |
| description | | description |
| "../RROType = 'UnnumberedRROType'"; | | "../RROType = 'UnnumberedRROType'"; |
| } | | } |
| description | | description |
| "Unnumbered RRO Sub Object"; | | "Unnumbered RRO Sub Object"; |
| uses RSVP-MGMT-RRO-UNNUMBERED-SUBOBJ; | | uses RSVP-MGMT-RRO-UNNUMBERED-SUBOBJ; |
| } | | } |
| container srlg-rro-sub-object { | | container srlg-rro-sub-object { |
| when "../rro-type = 'srlg-rro-type'" { | | when "../rro-type = 'srlg-rro-type'" { |
| description | | description |
| "../RROType = 'SRLG_RROType'"; | | "../RROType = 'SRLG_RROType'"; |
| } | | } |
| description | | description |
| "SRLG RRO Sub Object"; | | "SRLG RRO Sub Object"; |
| uses RSVP-MGMT-RRO-SRLG-SUBOBJ; | | uses RSVP-MGMT-RRO-SRLG-SUBOBJ; |
| } | | } |
| leaf rro-type { | | leaf rro-type { |
| type Rsvp-mgmt-rro-subobj; | | type Rsvp-mgmt-rro-subobj; |
| description | | description |
| "RROType"; | | "RROType"; |
| } | | } |
| } | | } |
| | | |
| grouping RSVP-MGMT-ERO-UNNUM-SUBOBJ { | | grouping RSVP-MGMT-ERO-UNNUM-SUBOBJ { |
| description | | description |
| "RSVP ERO UNNUM subobject"; | | "RSVP ERO UNNUM subobject"; |
| leaf is-strict-route { | | leaf is-strict-route { |
| type boolean; | | type boolean; |
| description | | description |
| "ERO Entry Is Strict"; | | "ERO Entry Is Strict"; |
| } | | } |
| leaf ero-interface-id { | | leaf ero-interface-id { |
| type uint32; | | type uint32; |
| description | | description |
| "The Interface ID in ERO"; | | "The Interface ID in ERO"; |
| } | | } |
| leaf ero-router-id { | | leaf ero-router-id { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "The Router ID in ERO"; | | "The Router ID in ERO"; |
| } | | } |
| leaf status { | | leaf status { |
| type Rsvp-mgmt-ero-subobj-status; | | type Rsvp-mgmt-ero-subobj-status; |
| description | | description |
| "Status of ERO"; | | "Status of ERO"; |
| } | | } |
| } | | } |
| | | |
| grouping RSVP-MGMT-ERO-IPV4-SUBOBJ { | | grouping RSVP-MGMT-ERO-IPV4-SUBOBJ { |
| description | | description |
| "RSVP ERO IPV4 subobject"; | | "RSVP ERO IPV4 subobject"; |
| leaf is-strict-route { | | leaf is-strict-route { |
| type boolean; | | type boolean; |
| description | | description |
| "ERO Entry Is Strict"; | | "ERO Entry Is Strict"; |
| } | | } |
| leaf ero-address { | | leaf ero-address { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "The ERO IPV4 Address"; | | "The ERO IPV4 Address"; |
| } | | } |
| leaf prefix-length { | | leaf prefix-length { |
| type uint8; | | type uint8; |
| description | | description |
| "ERO Prefix Length"; | | "ERO Prefix Length"; |
| } | | } |
| } | | } |
| | | |
| grouping RSVP-MGMT-ERO-SUBOBJ { | | grouping RSVP-MGMT-ERO-SUBOBJ { |
| description | | description |
| "Union of the different RSVP ERO types"; | | "Union of the different RSVP ERO types"; |
| container ipv4ero-sub-object { | | container ipv4ero-sub-object { |
| when "../ero-type = 'rsvp-mgmt-ero-type-ipv4'" { | | when "../ero-type = 'rsvp-mgmt-ero-type-ipv4'" { |
| description | | description |
| "../EROType = 'RSVP_MGMT_ERO_TYPE_IPv4'"; | | "../EROType = 'RSVP_MGMT_ERO_TYPE_IPv4'"; |
| } | | } |
| description | | description |
| "IPV4 ERO Sub Object"; | | "IPV4 ERO Sub Object"; |
| uses RSVP-MGMT-ERO-IPV4-SUBOBJ; | | uses RSVP-MGMT-ERO-IPV4-SUBOBJ; |
| } | | } |
| container unnumbered-ero-sub-object { | | container unnumbered-ero-sub-object { |
| when "../ero-type = 'rsvp-mgmt-ero-type-un-num'" { | | when "../ero-type = 'rsvp-mgmt-ero-type-un-num'" { |
| description | | description |
| "../EROType = 'RSVP_MGMT_ERO_TYPE_UNNUM'"; | | "../EROType = 'RSVP_MGMT_ERO_TYPE_UNNUM'"; |
| } | | } |
| description | | description |
| "Unnumbered ERO Sub Object"; | | "Unnumbered ERO Sub Object"; |
| uses RSVP-MGMT-ERO-UNNUM-SUBOBJ; | | uses RSVP-MGMT-ERO-UNNUM-SUBOBJ; |
| } | | } |
| leaf ero-type { | | leaf ero-type { |
| type Rsvp-mgmt-ero-subobj; | | type Rsvp-mgmt-ero-subobj; |
| description | | description |
| "EROType"; | | "EROType"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-P2MP-SIG-ERROR { | | grouping MPLS-TE-P2MP-SIG-ERROR { |
| description | | description |
| "P2MP signalling error"; | | "P2MP signalling error"; |
| leaf error-node { | | leaf error-node { |
| type uint32; | | type uint32; |
| description | | description |
| "Source address of the error generating node"; | | "Source address of the error generating node"; |
| } | | } |
| leaf error { | | leaf error { |
| type uint8; | | type uint8; |
| description | | description |
| "Path Error code"; | | "Path Error code"; |
| } | | } |
| leaf sub-code { | | leaf sub-code { |
| type uint16; | | type uint16; |
| description | | description |
| "Path Error subcode"; | | "Path Error subcode"; |
| } | | } |
| leaf lsp-mode { | | leaf lsp-mode { |
| type Mpls-te-lsp-mode; | | type Mpls-te-lsp-mode; |
| description | | description |
| "LSPMode"; | | "LSPMode"; |
| } | | } |
| leaf log-time { | | leaf log-time { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Time in seconds when the error message is logged"; | | "Time in seconds when the error message is logged"; |
| } | | } |
| leaf signalling-lsp-id { | | leaf signalling-lsp-id { |
| type uint16; | | type uint16; |
| description | | description |
| "LSP-id for which the error was received"; | | "LSP-id for which the error was received"; |
| } | | } |
| leaf error-message { | | leaf error-message { |
| type string; | | type string; |
| description | | description |
| "Error message (for display purposes only)"; | | "Error message (for display purposes only)"; |
| } | | } |
| leaf reverse-lsp { | | leaf reverse-lsp { |
| type boolean; | | type boolean; |
| description | | description |
| "Indicates if error is on the reverse LSP"; | | "Indicates if error is on the reverse LSP"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-P2MP-PCALC-ERROR { | | grouping MPLS-TE-P2MP-PCALC-ERROR { |
| description | | description |
| "Path computation error information"; | | "Path computation error information"; |
| leaf error-message { | | leaf error-message { |
| type string; | | type string; |
| description | | description |
| "Error message (for display purposes only)"; | | "Error message (for display purposes only)"; |
| } | | } |
| leaf lsp-mode { | | leaf lsp-mode { |
| type Mpls-te-lsp-mode; | | type Mpls-te-lsp-mode; |
| description | | description |
| "LSP Mode"; | | "LSP Mode"; |
| } | | } |
| leaf log-time { | | leaf log-time { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Time in seconds seconds (since Jan. 1, 1970) | | "Time in seconds seconds (since Jan. 1, 1970) |
| when the error message is logged"; | | when the error message is logged"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-ATTRIBUTE-SET-UNI-P { | | grouping MPLS-TE-ATTRIBUTE-SET-UNI-P { |
| description | | description |
| "UNI protection attribute set"; | | "UNI protection attribute set"; |
| leaf lsp-flag { | | leaf lsp-flag { |
| type Te-protection; | | type Te-protection; |
| description | | description |
| "End-end protection type"; | | "End-end protection type"; |
| } | | } |
| leaf seg-flag { | | leaf seg-flag { |
| type Te-protection; | | type Te-protection; |
| description | | description |
| "Segment protection type"; | | "Segment protection type"; |
| } | | } |
| leaf in-place-bit { | | leaf in-place-bit { |
| type boolean; | | type boolean; |
| description | | description |
| "In place bit"; | | "In place bit"; |
| } | | } |
| leaf required-bit { | | leaf required-bit { |
| type boolean; | | type boolean; |
| description | | description |
| "Required Bit"; | | "Required Bit"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-ATTRIBUTE-SET-SR-PREPEND-ENTRY { | | grouping MPLS-TE-ATTRIBUTE-SET-SR-PREPEND-ENTRY { |
| description | | description |
| "TE segment routing prepend entry"; | | "TE segment routing prepend entry"; |
| leaf type { | | leaf type { |
| type Te-attribute-set-sr-prepend; | | type Te-attribute-set-sr-prepend; |
| description | | description |
| "Prepend Type"; | | "Prepend Type"; |
| } | | } |
| leaf index { | | leaf index { |
| type uint32; | | type uint32; |
| description | | description |
| "Prepend index"; | | "Prepend index"; |
| } | | } |
| leaf next-label { | | leaf next-label { |
| type uint32; | | type uint32; |
| description | | description |
| "Prepend next label"; | | "Prepend next label"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-ATTRIBUTE-SET-SR-PREPEND-LIST { | | grouping MPLS-TE-ATTRIBUTE-SET-SR-PREPEND-LIST { |
| description | | description |
| "TE segment routing prepend list"; | | "TE segment routing prepend list"; |
| list prepend-entry { | | list prepend-entry { |
| description | | description |
| "List of prepend entries"; | | "List of prepend entries"; |
| uses MPLS-TE-ATTRIBUTE-SET-SR-PREPEND-ENTRY; | | uses MPLS-TE-ATTRIBUTE-SET-SR-PREPEND-ENTRY; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-ATTRIBUTE-SET-P2P-TE { | | grouping MPLS-TE-ATTRIBUTE-SET-P2P-TE { |
| description | | description |
| "TE P2P-TE Attribute Set"; | | "TE P2P-TE Attribute Set"; |
| container affinity { | | container affinity { |
| description | | description |
| "Affinity"; | | "Affinity"; |
| uses MPLS-TE-TUNNELS-AFFINITY-INFO; | | uses MPLS-TE-TUNNELS-AFFINITY-INFO; |
| } | | } |
| container logging { | | container logging { |
| description | | description |
| "Logging attributes"; | | "Logging attributes"; |
| uses MPLS-TE-LOGGING-ATTRIBUTES; | | uses MPLS-TE-LOGGING-ATTRIBUTES; |
| } | | } |
| container prepend-list { | | container prepend-list { |
| description | | description |
| "SR prepend list"; | | "SR prepend list"; |
| uses MPLS-TE-ATTRIBUTE-SET-SR-PREPEND-LIST; | | uses MPLS-TE-ATTRIBUTE-SET-SR-PREPEND-LIST; |
| } | | } |
| leaf is-affinity-configured { | | leaf is-affinity-configured { |
| type boolean; | | type boolean; |
| description | | description |
| "Is affinity configured"; | | "Is affinity configured"; |
| } | | } |
| leaf path-selection-segment-routing-adjacency-protection { | | leaf path-selection-segment-routing-adjacency-protection { |
| type Te-s2l-sr-path-selection; | | type Te-s2l-sr-path-selection; |
| description | | description |
| "Path selection segment-routing type"; | | "Path selection segment-routing type"; |
| } | | } |
| leaf is-path-selection-segment-routing-adjacency-protection-configured { | | leaf is-path-selection-segment-routing-adjacency-protection-configured { |
| type boolean; | | type boolean; |
| description | | description |
| "Is path selection segment routing configured"; | | "Is path selection segment routing configured"; |
| } | | } |
| leaf path-invalidation-timeout { | | leaf path-invalidation-timeout { |
| type uint32; | | type uint32; |
| description | | description |
| "Path invalidation timeout on the tunnel path"; | | "Path invalidation timeout on the tunnel path"; |
| } | | } |
| leaf path-selection-invalidation-action { | | leaf path-selection-invalidation-action { |
| type Te-path-inval-action; | | type Te-path-inval-action; |
| description | | description |
| "Path invalidation action"; | | "Path invalidation action"; |
| } | | } |
| leaf is-path-invalidation-timeout-configured { | | leaf is-path-invalidation-timeout-configured { |
| type boolean; | | type boolean; |
| description | | description |
| "Is Path Invalidation timeout configured"; | | "Is Path Invalidation timeout configured"; |
| } | | } |
| leaf is-path-invalidation-action-configured { | | leaf is-path-invalidation-action-configured { |
| type boolean; | | type boolean; |
| description | | description |
| "Is Path Invalidation action configured"; | | "Is Path Invalidation action configured"; |
| } | | } |
| leaf path-selection-metric { | | leaf path-selection-metric { |
| type Mpls-te-metric; | | type Mpls-te-metric; |
| description | | description |
| "Path selection metric type"; | | "Path selection metric type"; |
| } | | } |
| leaf is-path-selection-metric-configured { | | leaf is-path-selection-metric-configured { |
| type boolean; | | type boolean; |
| description | | description |
| "Is path selection metric configured"; | | "Is path selection metric configured"; |
| } | | } |
| leaf path-selection-segment-routing-margin { | | leaf path-selection-segment-routing-margin { |
| type uint32; | | type uint32; |
| description | | description |
| "Path selection margin"; | | "Path selection margin"; |
| } | | } |
| leaf is-path-selection-segment-routing-margin-relative { | | leaf is-path-selection-segment-routing-margin-relative { |
| type boolean; | | type boolean; |
| description | | description |
| "Path selection margin is_relative"; | | "Path selection margin is_relative"; |
| } | | } |
| leaf is-path-selection-segment-routing-margin-configured { | | leaf is-path-selection-segment-routing-margin-configured { |
| type boolean; | | type boolean; |
| description | | description |
| "Is path selection margin configured"; | | "Is path selection margin configured"; |
| } | | } |
| leaf path-selection-segment-routing-segment-limit { | | leaf path-selection-segment-routing-segment-limit { |
| type uint32; | | type uint32; |
| description | | description |
| "Is path selection segment limit configured"; | | "Is path selection segment limit configured"; |
| } | | } |
| leaf is-path-selection-segment-routing-segment-limit-configured { | | leaf is-path-selection-segment-routing-segment-limit-configured { |
| type boolean; | | type boolean; |
| description | | description |
| "Is path selection segment limit configured"; | | "Is path selection segment limit configured"; |
| } | | } |
| leaf is-path-select-configured { | | leaf is-path-select-configured { |
| type boolean; | | type boolean; |
| description | | description |
| "Is any of the path selection parameters | | "Is any of the path selection parameters |
| configured"; | | configured"; |
| } | | } |
| leaf is-prepend-list-configured { | | leaf is-prepend-list-configured { |
| type boolean; | | type boolean; |
| description | | description |
| "Is SR prepend list configured"; | | "Is SR prepend list configured"; |
| } | | } |
| leaf is-pce-configured { | | leaf is-pce-configured { |
| type boolean; | | type boolean; |
| description | | description |
| "Is PCE Configured"; | | "Is PCE Configured"; |
| } | | } |
| leaf is-pce-disj-source-configured { | | leaf is-pce-disj-source-configured { |
| type boolean; | | type boolean; |
| description | | description |
| "Is PCE Disjoint Path Source Configured"; | | "Is PCE Disjoint Path Source Configured"; |
| } | | } |
| leaf is-pce-disj-type-configured { | | leaf is-pce-disj-type-configured { |
| type boolean; | | type boolean; |
| description | | description |
| "Is PCE Disjoint Path Type Configured"; | | "Is PCE Disjoint Path Type Configured"; |
| } | | } |
| leaf is-pce-disj-group-id-configured { | | leaf is-pce-disj-group-id-configured { |
| type boolean; | | type boolean; |
| description | | description |
| "Is PCE Disjoint Path Group ID Configured"; | | "Is PCE Disjoint Path Group ID Configured"; |
| } | | } |
| leaf pcedp-source-address { | | leaf pcedp-source-address { |
| type uint32; | | type uint32; |
| description | | description |
| "PCE Disjoint Path Source Address"; | | "PCE Disjoint Path Source Address"; |
| } | | } |
| leaf pcedp-type { | | leaf pcedp-type { |
| type Te-pce-disjoint; | | type Te-pce-disjoint; |
| description | | description |
| "PCE Disjoint Path Type"; | | "PCE Disjoint Path Type"; |
| } | | } |
| leaf pcedp-group-id { | | leaf pcedp-group-id { |
| type uint32; | | type uint32; |
| description | | description |
| "PCE Disjoint Path Group ID"; | | "PCE Disjoint Path Group ID"; |
| } | | } |
| leaf is-pceb-dj-source-configured { | | leaf is-pceb-dj-source-configured { |
| type boolean; | | type boolean; |
| description | | description |
| "Is PCE Bidirectional Source Configured"; | | "Is PCE Bidirectional Source Configured"; |
| } | | } |
| leaf is-pcebd-group-id-configured { | | leaf is-pcebd-group-id-configured { |
| type boolean; | | type boolean; |
| description | | description |
| "Is PCE Bidirectional Group ID Configured"; | | "Is PCE Bidirectional Group ID Configured"; |
| } | | } |
| leaf pcebd-source-address { | | leaf pcebd-source-address { |
| type uint32; | | type uint32; |
| description | | description |
| "PCE Bidirectional Source Address"; | | "PCE Bidirectional Source Address"; |
| } | | } |
| leaf pcebd-group-id { | | leaf pcebd-group-id { |
| type uint32; | | type uint32; |
| description | | description |
| "PCE Bidirectional Group ID"; | | "PCE Bidirectional Group ID"; |
| } | | } |
| list tunnel-id { | | list tunnel-id { |
| description | | description |
| "Tunnel ID"; | | "Tunnel ID"; |
| leaf entry { | | leaf entry { |
| type uint16; | | type uint16; |
| description | | description |
| "Tunnel ID"; | | "Tunnel ID"; |
| } | | } |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-ATTRIBUTE-SET-APS-PP { | | grouping MPLS-TE-ATTRIBUTE-SET-APS-PP { |
| description | | description |
| "TE OTN path protection attribute set"; | | "TE OTN path protection attribute set"; |
| container revert-schedule { | | container revert-schedule { |
| description | | description |
| "Revert Schedule"; | | "Revert Schedule"; |
| uses TE-REVERT-SCH; | | uses TE-REVERT-SCH; |
| } | | } |
| leaf snc-mode { | | leaf snc-mode { |
| type Te-aps-snc-mode; | | type Te-aps-snc-mode; |
| description | | description |
| "Sub-network Connection Mode"; | | "Sub-network Connection Mode"; |
| } | | } |
| leaf tcm-id { | | leaf tcm-id { |
| type uint32; | | type uint32; |
| description | | description |
| "Sub-network Connection Monitoring Mode"; | | "Sub-network Connection Monitoring Mode"; |
| } | | } |
| leaf protection-type { | | leaf protection-type { |
| type Te-protect; | | type Te-protect; |
| description | | description |
| "Protection Type"; | | "Protection Type"; |
| } | | } |
| leaf protection-mode { | | leaf protection-mode { |
| type Te-pnr-revert-options; | | type Te-pnr-revert-options; |
| description | | description |
| "Protection Restoration Mode"; | | "Protection Restoration Mode"; |
| } | | } |
| leaf wait-to-restore-time { | | leaf wait-to-restore-time { |
| type uint32; | | type uint32; |
| description | | description |
| "Wait to restore time"; | | "Wait to restore time"; |
| } | | } |
| leaf hold-off-time { | | leaf hold-off-time { |
| type uint32; | | type uint32; |
| description | | description |
| "Hold-off time"; | | "Hold-off time"; |
| } | | } |
| leaf path-prot-profile-type { | | leaf path-prot-profile-type { |
| type Te-path-prot-profile; | | type Te-path-prot-profile; |
| description | | description |
| "Path Protection Profile Type"; | | "Path Protection Profile Type"; |
| } | | } |
| leaf restoration-style { | | leaf restoration-style { |
| type Te-restoration-style; | | type Te-restoration-style; |
| description | | description |
| "Restoration Style"; | | "Restoration Style"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-ATTRIBUTE-SET-P2MP-TE { | | grouping MPLS-TE-ATTRIBUTE-SET-P2MP-TE { |
| description | | description |
| "TE P2MP-TE Attribute Set"; | | "TE P2MP-TE Attribute Set"; |
| container affinity { | | container affinity { |
| description | | description |
| "Affinity"; | | "Affinity"; |
| uses MPLS-TE-TUNNELS-AFFINITY-INFO; | | uses MPLS-TE-TUNNELS-AFFINITY-INFO; |
| } | | } |
| leaf fast-reroute { | | leaf fast-reroute { |
| type boolean; | | type boolean; |
| description | | description |
| "Fast reroute"; | | "Fast reroute"; |
| } | | } |
| leaf frr-bandwidth-protection { | | leaf frr-bandwidth-protection { |
| type boolean; | | type boolean; |
| description | | description |
| "FRR bandwidth protection"; | | "FRR bandwidth protection"; |
| } | | } |
| leaf setup-priority { | | leaf setup-priority { |
| type uint8; | | type uint8; |
| description | | description |
| "Setup priority"; | | "Setup priority"; |
| } | | } |
| leaf hold-priority { | | leaf hold-priority { |
| type uint8; | | type uint8; |
| description | | description |
| "Hold priority"; | | "Hold priority"; |
| } | | } |
| leaf is-priority-configured { | | leaf is-priority-configured { |
| type boolean; | | type boolean; |
| description | | description |
| "Is priority configured"; | | "Is priority configured"; |
| } | | } |
| leaf configured-bandwidth { | | leaf configured-bandwidth { |
| type uint32; | | type uint32; |
| units "kbit/s"; | | units "kbit/s"; |
| description | | description |
| "Bandwidth value in kbps"; | | "Bandwidth value in kbps"; |
| } | | } |
| leaf dste-class-type { | | leaf dste-class-type { |
| type uint8; | | type uint8; |
| description | | description |
| "DSTE Class"; | | "DSTE Class"; |
| } | | } |
| leaf is-bandwidth-configured { | | leaf is-bandwidth-configured { |
| type boolean; | | type boolean; |
| description | | description |
| "Is bandwidth configured"; | | "Is bandwidth configured"; |
| } | | } |
| leaf is-affinity-configured { | | leaf is-affinity-configured { |
| type boolean; | | type boolean; |
| description | | description |
| "Is affinity configured"; | | "Is affinity configured"; |
| } | | } |
| n | leaf auto-bandwidth-configured { | n | |
| type boolean; | | |
| description | | |
| "Is auto bandwidth configured"; | | |
| } | | |
| leaf soft-preemption-configured { | | |
| type boolean; | | |
| description | | |
| "Is soft preemption configured"; | | |
| } | | |
| list tunnel-id { | | list tunnel-id { |
| description | | description |
| "Tunnel ID"; | | "Tunnel ID"; |
| leaf entry { | | leaf entry { |
| type uint16; | | type uint16; |
| description | | description |
| "Tunnel ID"; | | "Tunnel ID"; |
| } | | } |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-ATTRIBUTE-SET-XRO { | | grouping MPLS-TE-ATTRIBUTE-SET-XRO { |
| description | | description |
| "TE XRO attribute set"; | | "TE XRO attribute set"; |
| container xro { | | container xro { |
| description | | description |
| "The XRO specified by this attribute-set"; | | "The XRO specified by this attribute-set"; |
| uses TE-XRO; | | uses TE-XRO; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-ATTRIBUTE-SET-AUTO-MESH { | | grouping MPLS-TE-ATTRIBUTE-SET-AUTO-MESH { |
| description | | description |
| "TE Auto-mesh Attribute Set"; | | "TE Auto-mesh Attribute Set"; |
| container affinity { | | container affinity { |
| description | | description |
| "Affinity"; | | "Affinity"; |
| uses MPLS-TE-TUNNELS-AFFINITY-INFO; | | uses MPLS-TE-TUNNELS-AFFINITY-INFO; |
| } | | } |
| container logging { | | container logging { |
| description | | description |
| "Logging attributes"; | | "Logging attributes"; |
| uses MPLS-TE-LOGGING-ATTRIBUTES; | | uses MPLS-TE-LOGGING-ATTRIBUTES; |
| } | | } |
| leaf configured-bandwidth { | | leaf configured-bandwidth { |
| type uint32; | | type uint32; |
| units "kbit/s"; | | units "kbit/s"; |
| description | | description |
| "Bandwidth value in kbps"; | | "Bandwidth value in kbps"; |
| } | | } |
| leaf dste-class-type { | | leaf dste-class-type { |
| type uint8; | | type uint8; |
| description | | description |
| "DSTE Class"; | | "DSTE Class"; |
| } | | } |
| leaf is-bandwidth-configured { | | leaf is-bandwidth-configured { |
| type boolean; | | type boolean; |
| description | | description |
| "Is bandwidth configured"; | | "Is bandwidth configured"; |
| } | | } |
| leaf setup-priority { | | leaf setup-priority { |
| type uint8; | | type uint8; |
| description | | description |
| "Setup priority"; | | "Setup priority"; |
| } | | } |
| leaf hold-priority { | | leaf hold-priority { |
| type uint8; | | type uint8; |
| description | | description |
| "Hold priority"; | | "Hold priority"; |
| } | | } |
| leaf is-priority-configured { | | leaf is-priority-configured { |
| type boolean; | | type boolean; |
| description | | description |
| "Is priority configured"; | | "Is priority configured"; |
| } | | } |
| leaf policy-class { | | leaf policy-class { |
| type uint8; | | type uint8; |
| description | | description |
| "deprecated"; | | "deprecated"; |
| } | | } |
| leaf is-policyclass-configured { | | leaf is-policyclass-configured { |
| type boolean; | | type boolean; |
| description | | description |
| "Is policy class configured"; | | "Is policy class configured"; |
| } | | } |
| leaf forward-class { | | leaf forward-class { |
| type uint32; | | type uint32; |
| description | | description |
| "Forward class"; | | "Forward class"; |
| } | | } |
| leaf is-forward-class-configured { | | leaf is-forward-class-configured { |
| type boolean; | | type boolean; |
| description | | description |
| "True if forward-class is configured"; | | "True if forward-class is configured"; |
| } | | } |
| leaf is-affinity-configured { | | leaf is-affinity-configured { |
| type boolean; | | type boolean; |
| description | | description |
| "Is affinity configured"; | | "Is affinity configured"; |
| } | | } |
| leaf fast-reroute { | | leaf fast-reroute { |
| type boolean; | | type boolean; |
| description | | description |
| "Fast reroute"; | | "Fast reroute"; |
| } | | } |
| leaf frr-node-protection { | | leaf frr-node-protection { |
| type boolean; | | type boolean; |
| description | | description |
| "FRR Node protection"; | | "FRR Node protection"; |
| } | | } |
| leaf frr-bandwidth-protection { | | leaf frr-bandwidth-protection { |
| type boolean; | | type boolean; |
| description | | description |
| "FRR bandwidth protection"; | | "FRR bandwidth protection"; |
| } | | } |
| leaf record-route { | | leaf record-route { |
| type boolean; | | type boolean; |
| description | | description |
| "Record route"; | | "Record route"; |
| } | | } |
| leaf auto-bandwidth-collect { | | leaf auto-bandwidth-collect { |
| type boolean; | | type boolean; |
| description | | description |
| "Auto bandwidth collect only"; | | "Auto bandwidth collect only"; |
| } | | } |
| leaf auto-route-announce { | | leaf auto-route-announce { |
| type boolean; | | type boolean; |
| description | | description |
| "Announce auto route to IGP"; | | "Announce auto route to IGP"; |
| } | | } |
| leaf soft-preemption-configured { | | leaf soft-preemption-configured { |
| type boolean; | | type boolean; |
| description | | description |
| "Soft preemption is configured"; | | "Soft preemption is configured"; |
| } | | } |
| leaf bandwidth { | | leaf bandwidth { |
| type uint32; | | type uint32; |
| description | | description |
| "IM bandwidth"; | | "IM bandwidth"; |
| } | | } |
| leaf load-share { | | leaf load-share { |
| type uint32; | | type uint32; |
| description | | description |
| "Load Share"; | | "Load Share"; |
| } | | } |
| leaf is-interface-bw-configured { | | leaf is-interface-bw-configured { |
| type boolean; | | type boolean; |
| description | | description |
| "Is Interface BW configured"; | | "Is Interface BW configured"; |
| } | | } |
| list policy-class-entry { | | list policy-class-entry { |
| description | | description |
| "PBTS policy classes"; | | "PBTS policy classes"; |
| leaf entry { | | leaf entry { |
| type uint8; | | type uint8; |
| description | | description |
| "PBTS policy classes"; | | "PBTS policy classes"; |
| } | | } |
| } | | } |
| list mesh-group-id { | | list mesh-group-id { |
| description | | description |
| "Meshgroup ID"; | | "Meshgroup ID"; |
| leaf entry { | | leaf entry { |
| type uint32; | | type uint32; |
| description | | description |
| "Meshgroup ID"; | | "Meshgroup ID"; |
| } | | } |
| } | | } |
| list tunnel-id { | | list tunnel-id { |
| description | | description |
| "Tunnel ID"; | | "Tunnel ID"; |
| leaf entry { | | leaf entry { |
| type uint16; | | type uint16; |
| description | | description |
| "Tunnel ID"; | | "Tunnel ID"; |
| } | | } |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-PROTECTED-IF-NAME-STR { | | grouping MPLS-TE-PROTECTED-IF-NAME-STR { |
| description | | description |
| "TE Protected Interface Name String"; | | "TE Protected Interface Name String"; |
| leaf protected-interface { | | leaf protected-interface { |
| type string; | | type string; |
| description | | description |
| "Protected Interface Name"; | | "Protected Interface Name"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-LOGGING-ATTRIBUTES { | | grouping MPLS-TE-LOGGING-ATTRIBUTES { |
| description | | description |
| "TE Logging Attributes"; | | "TE Logging Attributes"; |
| leaf lsp-state { | | leaf lsp-state { |
| type boolean; | | type boolean; |
| description | | description |
| "LSP State logging: TRUE - enabled, FALSE - | | "LSP State logging: TRUE - enabled, FALSE - |
| disabled"; | | disabled"; |
| } | | } |
| leaf s2l-state { | | leaf s2l-state { |
| type boolean; | | type boolean; |
| description | | description |
| "S2L State logging: TRUE - enabled, FALSE - | | "S2L State logging: TRUE - enabled, FALSE - |
| disabled"; | | disabled"; |
| } | | } |
| leaf lsp-re-route { | | leaf lsp-re-route { |
| type boolean; | | type boolean; |
| description | | description |
| "LSP re-route logging: TRUE - enabled, FALSE - | | "LSP re-route logging: TRUE - enabled, FALSE - |
| disabled"; | | disabled"; |
| } | | } |
| leaf lsp-re-opt { | | leaf lsp-re-opt { |
| type boolean; | | type boolean; |
| description | | description |
| "LSP re-optimization logging: TRUE - enabled, | | "LSP re-optimization logging: TRUE - enabled, |
| FALSE - disabled"; | | FALSE - disabled"; |
| } | | } |
| leaf lsp-insufficient-bw { | | leaf lsp-insufficient-bw { |
| type boolean; | | type boolean; |
| description | | description |
| "LSP insufficient bandwidth logging: TRUE - | | "LSP insufficient bandwidth logging: TRUE - |
| enabled, FALSE - disabled"; | | enabled, FALSE - disabled"; |
| } | | } |
| leaf lsp-bandwidth-change { | | leaf lsp-bandwidth-change { |
| type boolean; | | type boolean; |
| description | | description |
| "LSP bandwidth change logging: TRUE - enabled, | | "LSP bandwidth change logging: TRUE - enabled, |
| FALSE - disabled"; | | FALSE - disabled"; |
| } | | } |
| leaf lsp-pcalc-failure-logging-enabled { | | leaf lsp-pcalc-failure-logging-enabled { |
| type boolean; | | type boolean; |
| description | | description |
| "LSP pcalc failure logging: TRUE - enabled, FALSE | | "LSP pcalc failure logging: TRUE - enabled, FALSE |
| - disabled"; | | - disabled"; |
| } | | } |
| leaf all-logging-enabled { | | leaf all-logging-enabled { |
| type boolean; | | type boolean; |
| description | | description |
| "All logging option: TRUE - enabled, FALSE - | | "All logging option: TRUE - enabled, FALSE - |
| disabled"; | | disabled"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-ATTRIBUTE-SET-SIG-NAME { | | grouping MPLS-TE-ATTRIBUTE-SET-SIG-NAME { |
| description | | description |
| "Attribute set signalled name"; | | "Attribute set signalled name"; |
| leaf name { | | leaf name { |
| type string; | | type string; |
| description | | description |
| "Signalled name"; | | "Signalled name"; |
| } | | } |
| leaf source-type { | | leaf source-type { |
| type Te-sig-name-append; | | type Te-sig-name-append; |
| description | | description |
| "Source address or name"; | | "Source address or name"; |
| } | | } |
| leaf protected-interface-type { | | leaf protected-interface-type { |
| type Te-sig-name-append; | | type Te-sig-name-append; |
| description | | description |
| "Protected interface address or name"; | | "Protected interface address or name"; |
| } | | } |
| leaf is-mp-addresses { | | leaf is-mp-addresses { |
| type boolean; | | type boolean; |
| description | | description |
| "MP address appended"; | | "MP address appended"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-ATTRIBUTE-SET-AUTO-BACKUP { | | grouping MPLS-TE-ATTRIBUTE-SET-AUTO-BACKUP { |
| description | | description |
| "TE Auto-backup Attribute Set"; | | "TE Auto-backup Attribute Set"; |
| container signalled-name { | | container signalled-name { |
| description | | description |
| "Signalled name"; | | "Signalled name"; |
| uses MPLS-TE-ATTRIBUTE-SET-SIG-NAME; | | uses MPLS-TE-ATTRIBUTE-SET-SIG-NAME; |
| } | | } |
| container affinity { | | container affinity { |
| description | | description |
| "Affinity"; | | "Affinity"; |
| uses MPLS-TE-TUNNELS-AFFINITY-INFO; | | uses MPLS-TE-TUNNELS-AFFINITY-INFO; |
| } | | } |
| container logging { | | container logging { |
| description | | description |
| "Logging attributes"; | | "Logging attributes"; |
| uses MPLS-TE-LOGGING-ATTRIBUTES; | | uses MPLS-TE-LOGGING-ATTRIBUTES; |
| } | | } |
| leaf is-signalled-name-configured { | | leaf is-signalled-name-configured { |
| type boolean; | | type boolean; |
| description | | description |
| "Is signalled name configured"; | | "Is signalled name configured"; |
| } | | } |
| leaf setup-priority { | | leaf setup-priority { |
| type uint8; | | type uint8; |
| description | | description |
| "Setup priority"; | | "Setup priority"; |
| } | | } |
| leaf hold-priority { | | leaf hold-priority { |
| type uint8; | | type uint8; |
| description | | description |
| "Hold priority"; | | "Hold priority"; |
| } | | } |
| leaf is-priority-configured { | | leaf is-priority-configured { |
| type boolean; | | type boolean; |
| description | | description |
| "Is priority configured"; | | "Is priority configured"; |
| } | | } |
| leaf policy-class { | | leaf policy-class { |
| type uint8; | | type uint8; |
| description | | description |
| "deprecated"; | | "deprecated"; |
| } | | } |
| leaf is-policyclass-configured { | | leaf is-policyclass-configured { |
| type boolean; | | type boolean; |
| description | | description |
| "Is policy class configured"; | | "Is policy class configured"; |
| } | | } |
| leaf is-affinity-configured { | | leaf is-affinity-configured { |
| type boolean; | | type boolean; |
| description | | description |
| "Is affinity configured"; | | "Is affinity configured"; |
| } | | } |
| leaf record-route { | | leaf record-route { |
| type boolean; | | type boolean; |
| description | | description |
| "Record route"; | | "Record route"; |
| } | | } |
| list policy-class-entry { | | list policy-class-entry { |
| description | | description |
| "PBTS policy classes"; | | "PBTS policy classes"; |
| leaf entry { | | leaf entry { |
| type uint8; | | type uint8; |
| description | | description |
| "PBTS policy classes"; | | "PBTS policy classes"; |
| } | | } |
| } | | } |
| list tunnel-id { | | list tunnel-id { |
| description | | description |
| "Tunnel ID"; | | "Tunnel ID"; |
| leaf entry { | | leaf entry { |
| type uint16; | | type uint16; |
| description | | description |
| "Tunnel ID"; | | "Tunnel ID"; |
| } | | } |
| } | | } |
| list protected-interface { | | list protected-interface { |
| description | | description |
| "Array of Protected Interface Names"; | | "Array of Protected Interface Names"; |
| uses MPLS-TE-PROTECTED-IF-NAME-STR; | | uses MPLS-TE-PROTECTED-IF-NAME-STR; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-ATTRIBUTE-SET-BFD-REV-PATH { | | grouping MPLS-TE-ATTRIBUTE-SET-BFD-REV-PATH { |
| description | | description |
| "TE segment routing path list"; | | "TE segment routing path list"; |
| leaf path-type { | | leaf path-type { |
| type Te-bfd-reverse-path; | | type Te-bfd-reverse-path; |
| description | | description |
| "BFD reverse path type"; | | "BFD reverse path type"; |
| } | | } |
| leaf binding-label { | | leaf binding-label { |
| type uint32; | | type uint32; |
| description | | description |
| "BFD reverse path binding label"; | | "BFD reverse path binding label"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-ATTRIBUTE-SET-VERSION { | | grouping MPLS-TE-ATTRIBUTE-SET-VERSION { |
| description | | description |
| "TE attribute set versioning info"; | | "TE attribute set versioning info"; |
| leaf attribute-type { | | leaf attribute-type { |
| type string; | | type string; |
| description | | description |
| "Attribute Type"; | | "Attribute Type"; |
| } | | } |
| leaf generation { | | leaf generation { |
| type uint32; | | type uint32; |
| description | | description |
| "Generation"; | | "Generation"; |
| } | | } |
| leaf is-default { | | leaf is-default { |
| type boolean; | | type boolean; |
| description | | description |
| "Is default"; | | "Is default"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-ATTRIBUTE-SET-PATH-OPTION { | | grouping MPLS-TE-ATTRIBUTE-SET-PATH-OPTION { |
| description | | description |
| "TE Path Option Attribute Set"; | | "TE Path Option Attribute Set"; |
| container affinity { | | container affinity { |
| description | | description |
| "Affinity"; | | "Affinity"; |
| uses MPLS-TE-TUNNELS-AFFINITY-INFO; | | uses MPLS-TE-TUNNELS-AFFINITY-INFO; |
| } | | } |
| container bfd-reverse-path { | | container bfd-reverse-path { |
| description | | description |
| "BFD reverse path"; | | "BFD reverse path"; |
| uses MPLS-TE-ATTRIBUTE-SET-BFD-REV-PATH; | | uses MPLS-TE-ATTRIBUTE-SET-BFD-REV-PATH; |
| } | | } |
| leaf configured-bandwidth { | | leaf configured-bandwidth { |
| type uint32; | | type uint32; |
| units "kbit/s"; | | units "kbit/s"; |
| description | | description |
| "Bandwidth value in kbps"; | | "Bandwidth value in kbps"; |
| } | | } |
| leaf cost-limit { | | leaf cost-limit { |
| type uint32; | | type uint32; |
| description | | description |
| "Cost limit on the tunnel path"; | | "Cost limit on the tunnel path"; |
| } | | } |
| leaf dste-class-type { | | leaf dste-class-type { |
| type uint8; | | type uint8; |
| description | | description |
| "DSTE Class"; | | "DSTE Class"; |
| } | | } |
| leaf bandwidth-type { | | leaf bandwidth-type { |
| type Mpls-te-bw-pool; | | type Mpls-te-bw-pool; |
| description | | description |
| "The bandwidth type"; | | "The bandwidth type"; |
| } | | } |
| leaf is-bandwidth-configured { | | leaf is-bandwidth-configured { |
| type boolean; | | type boolean; |
| description | | description |
| "Is bandwidth configured"; | | "Is bandwidth configured"; |
| } | | } |
| leaf is-cost-limit-configured { | | leaf is-cost-limit-configured { |
| type boolean; | | type boolean; |
| description | | description |
| "Is Cost Limit configured"; | | "Is Cost Limit configured"; |
| } | | } |
| leaf is-affinity-configured { | | leaf is-affinity-configured { |
| type boolean; | | type boolean; |
| description | | description |
| "Is affinity configured"; | | "Is affinity configured"; |
| } | | } |
| leaf generation { | | leaf generation { |
| type uint32; | | type uint32; |
| description | | description |
| "Generation"; | | "Generation"; |
| } | | } |
| leaf path-invalidation-timeout { | | leaf path-invalidation-timeout { |
| type uint32; | | type uint32; |
| description | | description |
| "Path invalidation interval on the tunnel path"; | | "Path invalidation interval on the tunnel path"; |
| } | | } |
| leaf path-invalidation-action { | | leaf path-invalidation-action { |
| type uint32; | | type uint32; |
| description | | description |
| "Path invalidation action"; | | "Path invalidation action"; |
| } | | } |
| leaf is-path-invalidation-timeout-configured { | | leaf is-path-invalidation-timeout-configured { |
| type boolean; | | type boolean; |
| description | | description |
| "Is path invalidation timeout configured"; | | "Is path invalidation timeout configured"; |
| } | | } |
| leaf is-path-invalidation-action-configured { | | leaf is-path-invalidation-action-configured { |
| type boolean; | | type boolean; |
| description | | description |
| "Is path invalidation action configured"; | | "Is path invalidation action configured"; |
| } | | } |
| leaf exclude-list-name { | | leaf exclude-list-name { |
| type string; | | type string; |
| description | | description |
| "Exclude list name"; | | "Exclude list name"; |
| } | | } |
| leaf is-exclude-list-name-configured { | | leaf is-exclude-list-name-configured { |
| type boolean; | | type boolean; |
| description | | description |
| "Is exclude list name configured"; | | "Is exclude list name configured"; |
| } | | } |
| leaf is-pce-configured { | | leaf is-pce-configured { |
| type boolean; | | type boolean; |
| description | | description |
| "Is PCE Configured"; | | "Is PCE Configured"; |
| } | | } |
| leaf is-pce-disj-source-configured { | | leaf is-pce-disj-source-configured { |
| type boolean; | | type boolean; |
| description | | description |
| "Is PCE Disjoint Path Source Configured"; | | "Is PCE Disjoint Path Source Configured"; |
| } | | } |
| leaf is-pce-disj-type-configured { | | leaf is-pce-disj-type-configured { |
| type boolean; | | type boolean; |
| description | | description |
| "Is PCE Disjoint Path Type Configured"; | | "Is PCE Disjoint Path Type Configured"; |
| } | | } |
| leaf is-pce-disj-group-id-configured { | | leaf is-pce-disj-group-id-configured { |
| type boolean; | | type boolean; |
| description | | description |
| "Is PCE Disjoint Path Group ID Configured"; | | "Is PCE Disjoint Path Group ID Configured"; |
| } | | } |
| leaf pcedp-source-address { | | leaf pcedp-source-address { |
| type uint32; | | type uint32; |
| description | | description |
| "PCE Disjoint Path Source Address"; | | "PCE Disjoint Path Source Address"; |
| } | | } |
| leaf pcedp-type { | | leaf pcedp-type { |
| type Te-pce-disjoint; | | type Te-pce-disjoint; |
| description | | description |
| "PCE Disjoint Path Type"; | | "PCE Disjoint Path Type"; |
| } | | } |
| leaf pcedp-group-id { | | leaf pcedp-group-id { |
| type uint32; | | type uint32; |
| description | | description |
| "PCE Disjoint Path Group ID"; | | "PCE Disjoint Path Group ID"; |
| } | | } |
| leaf is-pceb-dj-source-configured { | | leaf is-pceb-dj-source-configured { |
| type boolean; | | type boolean; |
| description | | description |
| "Is PCE Bidirectional Source Configured"; | | "Is PCE Bidirectional Source Configured"; |
| } | | } |
| leaf is-pcebd-group-id-configured { | | leaf is-pcebd-group-id-configured { |
| type boolean; | | type boolean; |
| description | | description |
| "Is PCE Bidirectional Group ID Configured"; | | "Is PCE Bidirectional Group ID Configured"; |
| } | | } |
| leaf pcebd-source-address { | | leaf pcebd-source-address { |
| type uint32; | | type uint32; |
| description | | description |
| "PCE Bidirectional Source Address"; | | "PCE Bidirectional Source Address"; |
| } | | } |
| leaf pcebd-group-id { | | leaf pcebd-group-id { |
| type uint32; | | type uint32; |
| description | | description |
| "PCE Bidirectional Group ID"; | | "PCE Bidirectional Group ID"; |
| } | | } |
| leaf is-bfd-reverse-pat-configured { | | leaf is-bfd-reverse-pat-configured { |
| type boolean; | | type boolean; |
| description | | description |
| "Is BFD reverse path configured"; | | "Is BFD reverse path configured"; |
| } | | } |
| leaf is-delay-limit-configured { | | leaf is-delay-limit-configured { |
| type boolean; | | type boolean; |
| description | | description |
| "Is Delay Limit configured"; | | "Is Delay Limit configured"; |
| } | | } |
| leaf delay-limit { | | leaf delay-limit { |
| type uint32; | | type uint32; |
| description | | description |
| "Delay limit on the tunnel path (usec) When delay | | "Delay limit on the tunnel path (usec) When delay |
| limit is configured"; | | limit is configured"; |
| } | | } |
| list tunnel-id { | | list tunnel-id { |
| description | | description |
| "Tunnel ID"; | | "Tunnel ID"; |
| leaf entry { | | leaf entry { |
| type uint16; | | type uint16; |
| description | | description |
| "Tunnel ID"; | | "Tunnel ID"; |
| } | | } |
| } | | } |
| list version-info { | | list version-info { |
| description | | description |
| "Version Info"; | | "Version Info"; |
| uses MPLS-TE-ATTRIBUTE-SET-VERSION; | | uses MPLS-TE-ATTRIBUTE-SET-VERSION; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-ATTRIBUTE-SET-UNION { | | grouping MPLS-TE-ATTRIBUTE-SET-UNION { |
| description | | description |
| "TE Attribute Set Union"; | | "TE Attribute Set Union"; |
| container attribute-set-path-option { | | container attribute-set-path-option { |
| when "../tunnel-attribute-set-type = 'tunnel-attribute-set-path-option'" { | | when "../tunnel-attribute-set-type = 'tunnel-attribute-set-path-option'" { |
| description | | description |
| "../TunnelAttributeSetType = | | "../TunnelAttributeSetType = |
| 'TunnelAttributeSetPathOption'"; | | 'TunnelAttributeSetPathOption'"; |
| } | | } |
| description | | description |
| "MPLS TE Path Option Attribute Set"; | | "MPLS TE Path Option Attribute Set"; |
| uses MPLS-TE-ATTRIBUTE-SET-PATH-OPTION; | | uses MPLS-TE-ATTRIBUTE-SET-PATH-OPTION; |
| } | | } |
| container attribute-set-autobackup { | | container attribute-set-autobackup { |
| when "../tunnel-attribute-set-type = 'tunnel-attribute-set-auto-backup'" { | | when "../tunnel-attribute-set-type = 'tunnel-attribute-set-auto-backup'" { |
| description | | description |
| "../TunnelAttributeSetType = | | "../TunnelAttributeSetType = |
| 'TunnelAttributeSetAutoBackup'"; | | 'TunnelAttributeSetAutoBackup'"; |
| } | | } |
| description | | description |
| "MPLS TE Auto-backup Attribute Set"; | | "MPLS TE Auto-backup Attribute Set"; |
| uses MPLS-TE-ATTRIBUTE-SET-AUTO-BACKUP; | | uses MPLS-TE-ATTRIBUTE-SET-AUTO-BACKUP; |
| } | | } |
| container attribute-set-automesh { | | container attribute-set-automesh { |
| when "../tunnel-attribute-set-type = 'tunnel-attribute-set-auto-mesh'" { | | when "../tunnel-attribute-set-type = 'tunnel-attribute-set-auto-mesh'" { |
| description | | description |
| "../TunnelAttributeSetType = | | "../TunnelAttributeSetType = |
| 'TunnelAttributeSetAutoMesh'"; | | 'TunnelAttributeSetAutoMesh'"; |
| } | | } |
| description | | description |
| "MPLS TE Auto-mesh Attribute Set"; | | "MPLS TE Auto-mesh Attribute Set"; |
| uses MPLS-TE-ATTRIBUTE-SET-AUTO-MESH; | | uses MPLS-TE-ATTRIBUTE-SET-AUTO-MESH; |
| } | | } |
| container attribute-set-xro { | | container attribute-set-xro { |
| when "../tunnel-attribute-set-type = 'tunnel-attribute-set-xro'" { | | when "../tunnel-attribute-set-type = 'tunnel-attribute-set-xro'" { |
| description | | description |
| "../TunnelAttributeSetType = | | "../TunnelAttributeSetType = |
| 'TunnelAttributeSetXRO'"; | | 'TunnelAttributeSetXRO'"; |
| } | | } |
| description | | description |
| "Attribute Set XRO"; | | "Attribute Set XRO"; |
| uses MPLS-TE-ATTRIBUTE-SET-XRO; | | uses MPLS-TE-ATTRIBUTE-SET-XRO; |
| } | | } |
| container attribute-set-p2mpte { | | container attribute-set-p2mpte { |
| when "../tunnel-attribute-set-type = 'tunnel-attribute-set-p2mpte'" { | | when "../tunnel-attribute-set-type = 'tunnel-attribute-set-p2mpte'" { |
| description | | description |
| "../TunnelAttributeSetType = | | "../TunnelAttributeSetType = |
| 'TunnelAttributeSetP2MPTE'"; | | 'TunnelAttributeSetP2MPTE'"; |
| } | | } |
| description | | description |
| "MPLS TE P2MP-TE Attribute Set"; | | "MPLS TE P2MP-TE Attribute Set"; |
| uses MPLS-TE-ATTRIBUTE-SET-P2MP-TE; | | uses MPLS-TE-ATTRIBUTE-SET-P2MP-TE; |
| } | | } |
| container attribute-set-aps-pp { | | container attribute-set-aps-pp { |
| when "../tunnel-attribute-set-type = 'tunnel-attribute-aps-pp'" { | | when "../tunnel-attribute-set-type = 'tunnel-attribute-aps-pp'" { |
| description | | description |
| "../TunnelAttributeSetType = | | "../TunnelAttributeSetType = |
| 'TunnelAttributeAPS_PP'"; | | 'TunnelAttributeAPS_PP'"; |
| } | | } |
| description | | description |
| "Attribute Set OTN APS Path Protection"; | | "Attribute Set OTN APS Path Protection"; |
| uses MPLS-TE-ATTRIBUTE-SET-APS-PP; | | uses MPLS-TE-ATTRIBUTE-SET-APS-PP; |
| } | | } |
| container attribute-set-p2p-te { | | container attribute-set-p2p-te { |
| when "../tunnel-attribute-set-type = 'tunnel-attribute-set-p2p-te'" { | | when "../tunnel-attribute-set-type = 'tunnel-attribute-set-p2p-te'" { |
| description | | description |
| "../TunnelAttributeSetType = | | "../TunnelAttributeSetType = |
| 'TunnelAttributeSetP2P_TE'"; | | 'TunnelAttributeSetP2P_TE'"; |
| } | | } |
| description | | description |
| "MPLS TE P2P-TE Attribute Set"; | | "MPLS TE P2P-TE Attribute Set"; |
| uses MPLS-TE-ATTRIBUTE-SET-P2P-TE; | | uses MPLS-TE-ATTRIBUTE-SET-P2P-TE; |
| } | | } |
| container attribute-set-uni-p { | | container attribute-set-uni-p { |
| when "../tunnel-attribute-set-type = 'tunnel-attribute-uni-p'" { | | when "../tunnel-attribute-set-type = 'tunnel-attribute-uni-p'" { |
| description | | description |
| "../TunnelAttributeSetType = | | "../TunnelAttributeSetType = |
| 'TunnelAttributeUNI_P'"; | | 'TunnelAttributeUNI_P'"; |
| } | | } |
| description | | description |
| "Attribute Set UNI protection"; | | "Attribute Set UNI protection"; |
| uses MPLS-TE-ATTRIBUTE-SET-UNI-P; | | uses MPLS-TE-ATTRIBUTE-SET-UNI-P; |
| } | | } |
| leaf tunnel-attribute-set-type { | | leaf tunnel-attribute-set-type { |
| type Tunnel-attribute-set; | | type Tunnel-attribute-set; |
| description | | description |
| "TunnelAttributeSetType"; | | "TunnelAttributeSetType"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-ATTRIBUTE-SET { | | grouping MPLS-TE-ATTRIBUTE-SET { |
| description | | description |
| "TE Attribute Set"; | | "TE Attribute Set"; |
| container attribute-set-union { | | container attribute-set-union { |
| description | | description |
| "Union of Attribute Sets"; | | "Union of Attribute Sets"; |
| uses MPLS-TE-ATTRIBUTE-SET-UNION; | | uses MPLS-TE-ATTRIBUTE-SET-UNION; |
| } | | } |
| leaf tunnel-attribute-set-name { | | leaf tunnel-attribute-set-name { |
| type string; | | type string; |
| description | | description |
| "Attribute Set Name"; | | "Attribute Set Name"; |
| } | | } |
| leaf tunnel-attribute-set-name-crc32 { | | leaf tunnel-attribute-set-name-crc32 { |
| type uint32; | | type uint32; |
| description | | description |
| "Attribute Set name CRC32 value"; | | "Attribute Set name CRC32 value"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-P2MP-PATH-OPTION { | | grouping MPLS-TE-P2MP-PATH-OPTION { |
| description | | description |
| "P2MP path-option"; | | "P2MP path-option"; |
| container attribute-set { | | container attribute-set { |
| description | | description |
| "The path option attribute set used by this path"; | | "The path option attribute set used by this path"; |
| uses MPLS-TE-ATTRIBUTE-SET; | | uses MPLS-TE-ATTRIBUTE-SET; |
| } | | } |
| container xro-attribute-set { | | container xro-attribute-set { |
| description | | description |
| "The XRO attribute set used by this path-option"; | | "The XRO attribute set used by this path-option"; |
| uses MPLS-TE-ATTRIBUTE-SET; | | uses MPLS-TE-ATTRIBUTE-SET; |
| } | | } |
| leaf option-index-is-valid { | | leaf option-index-is-valid { |
| type boolean; | | type boolean; |
| description | | description |
| "The path option index is valid"; | | "The path option index is valid"; |
| } | | } |
| leaf option-index { | | leaf option-index { |
| type uint32; | | type uint32; |
| description | | description |
| "Path option index"; | | "Path option index"; |
| } | | } |
| leaf path-option-name { | | leaf path-option-name { |
| type string; | | type string; |
| description | | description |
| "Path option name"; | | "Path option name"; |
| } | | } |
| leaf path-option-type { | | leaf path-option-type { |
| type Mpls-te-pathoption; | | type Mpls-te-pathoption; |
| description | | description |
| "Path option type"; | | "Path option type"; |
| } | | } |
| leaf explicit-path-name { | | leaf explicit-path-name { |
| type string; | | type string; |
| description | | description |
| "Explicit Path Name, this is the key to table | | "Explicit Path Name, this is the key to table |
| ExplicitPaths.NameTable"; | | ExplicitPaths.NameTable"; |
| } | | } |
| leaf explicit-path-id { | | leaf explicit-path-id { |
| type uint16; | | type uint16; |
| description | | description |
| "Explicit Path ID, this is the key to table | | "Explicit Path ID, this is the key to table |
| ExplicitPaths.IdentifierTable"; | | ExplicitPaths.IdentifierTable"; |
| } | | } |
| leaf holddown-duration { | | leaf holddown-duration { |
| type uint16; | | type uint16; |
| units "second"; | | units "second"; |
| description | | description |
| "Holddown Duration (seconds)"; | | "Holddown Duration (seconds)"; |
| } | | } |
| leaf pce-address { | | leaf pce-address { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "PCE server address"; | | "PCE server address"; |
| } | | } |
| leaf path-option-area-id { | | leaf path-option-area-id { |
| type string; | | type string; |
| description | | description |
| "The path-option area constraint"; | | "The path-option area constraint"; |
| } | | } |
| leaf is-strict-explicit-path { | | leaf is-strict-explicit-path { |
| type boolean; | | type boolean; |
| description | | description |
| "TRUE if explicit path is strict"; | | "TRUE if explicit path is strict"; |
| } | | } |
| leaf is-helddown { | | leaf is-helddown { |
| type boolean; | | type boolean; |
| description | | description |
| "TRUE if path is helddown"; | | "TRUE if path is helddown"; |
| } | | } |
| leaf is-lockdown { | | leaf is-lockdown { |
| type boolean; | | type boolean; |
| description | | description |
| "TRUE if the path is locked down"; | | "TRUE if the path is locked down"; |
| } | | } |
| leaf is-sticky { | | leaf is-sticky { |
| type boolean; | | type boolean; |
| description | | description |
| "TRUE if the path is sticky"; | | "TRUE if the path is sticky"; |
| } | | } |
| leaf is-verbatim { | | leaf is-verbatim { |
| type boolean; | | type boolean; |
| description | | description |
| "TRUE if the path is verbatim"; | | "TRUE if the path is verbatim"; |
| } | | } |
| leaf is-disabled { | | leaf is-disabled { |
| type boolean; | | type boolean; |
| description | | description |
| "TRUE if the path option is disabled"; | | "TRUE if the path option is disabled"; |
| } | | } |
| leaf has-attribute-set { | | leaf has-attribute-set { |
| type boolean; | | type boolean; |
| description | | description |
| "TRUE if the path has an attribute set defined"; | | "TRUE if the path has an attribute set defined"; |
| } | | } |
| leaf attribute-set-found { | | leaf attribute-set-found { |
| type boolean; | | type boolean; |
| description | | description |
| "TRUE if the path has found the defined attribute | | "TRUE if the path has found the defined attribute |
| set"; | | set"; |
| } | | } |
| leaf has-xro-attribute-set { | | leaf has-xro-attribute-set { |
| type boolean; | | type boolean; |
| description | | description |
| "TRUE if the path has an XRO attribute set | | "TRUE if the path has an XRO attribute set |
| configured"; | | configured"; |
| } | | } |
| leaf xro-attribute-set-found { | | leaf xro-attribute-set-found { |
| type boolean; | | type boolean; |
| description | | description |
| "TRUE if the path's XRO attribute set is known"; | | "TRUE if the path's XRO attribute set is known"; |
| } | | } |
| leaf is-segment-routing { | | leaf is-segment-routing { |
| type boolean; | | type boolean; |
| description | | description |
| "TRUE if the path is Segment-Routing"; | | "TRUE if the path is Segment-Routing"; |
| } | | } |
| leaf protected-by-path-option-index { | | leaf protected-by-path-option-index { |
| type uint32; | | type uint32; |
| description | | description |
| "Path option index for Protect path options"; | | "Path option index for Protect path options"; |
| } | | } |
| leaf restored-from-path-option-index { | | leaf restored-from-path-option-index { |
| type uint32; | | type uint32; |
| description | | description |
| "Path option index for Restore path options"; | | "Path option index for Restore path options"; |
| } | | } |
| t | leaf setup-timeout { | t | |
| type uint16; | | |
| description | | |
| "Path setup retry timer timeout value"; | | |
| } | | |
| list path-calculation-error { | | list path-calculation-error { |
| description | | description |
| "Path computation information"; | | "Path computation information"; |
| uses MPLS-TE-P2MP-PCALC-ERROR; | | uses MPLS-TE-P2MP-PCALC-ERROR; |
| } | | } |
| list remerge-error { | | list remerge-error { |
| description | | description |
| "Path computation remerge resolve info"; | | "Path computation remerge resolve info"; |
| uses MPLS-TE-P2MP-PCALC-ERROR; | | uses MPLS-TE-P2MP-PCALC-ERROR; |
| } | | } |
| list signalling-error { | | list signalling-error { |
| description | | description |
| "Signalling information"; | | "Signalling information"; |
| uses MPLS-TE-P2MP-SIG-ERROR; | | uses MPLS-TE-P2MP-SIG-ERROR; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-P2MP-S2L { | | grouping MPLS-TE-P2MP-S2L { |
| description | | description |
| "A P2MP S2L"; | | "A P2MP S2L"; |
| container s2l-fec { | | container s2l-fec { |
| description | | description |
| "FEC for the S2L"; | | "FEC for the S2L"; |
| uses TE-S2L-FEC; | | uses TE-S2L-FEC; |
| } | | } |
| container active-path-option { | | container active-path-option { |
| description | | description |
| "The path option used to find the path for this | | "The path option used to find the path for this |
| S2L"; | | S2L"; |
| uses MPLS-TE-P2MP-PATH-OPTION; | | uses MPLS-TE-P2MP-PATH-OPTION; |
| } | | } |
| container out-xro { | | container out-xro { |
| description | | description |
| "Outgoing XRO for this S2L"; | | "Outgoing XRO for this S2L"; |
| uses TE-XRO; | | uses TE-XRO; |
| } | | } |
| container in-xro { | | container in-xro { |
| description | | description |
| "Incoming XRO for this S2L"; | | "Incoming XRO for this S2L"; |
| uses TE-XRO; | | uses TE-XRO; |
| } | | } |
| container tspec { | | container tspec { |
| description | | description |
| "The T spec info"; | | "The T spec info"; |
| uses BANDWIDTH-SPEC-BAG; | | uses BANDWIDTH-SPEC-BAG; |
| } | | } |
| container generic-tspec { | | container generic-tspec { |
| description | | description |
| "Generic TSpec"; | | "Generic TSpec"; |
| uses TE-MGMT-GENERIC-TSPEC; | | uses TE-MGMT-GENERIC-TSPEC; |
| } | | } |
| container fspec { | | container fspec { |
| description | | description |
| "The F spec info"; | | "The F spec info"; |
| uses BANDWIDTH-SPEC-BAG; | | uses BANDWIDTH-SPEC-BAG; |
| } | | } |
| container generic-fspec { | | container generic-fspec { |
| description | | description |
| "Generic FSpec"; | | "Generic FSpec"; |
| uses TE-MGMT-GENERIC-FSPEC; | | uses TE-MGMT-GENERIC-FSPEC; |
| } | | } |
| container next-hop-address-generic { | | container next-hop-address-generic { |
| description | | description |
| "Next hop address"; | | "Next hop address"; |
| uses TE-ADDR; | | uses TE-ADDR; |
| } | | } |
| container previous-hop-address-generic { | | container previous-hop-address-generic { |
| description | | description |
| "Previous hop address"; | | "Previous hop address"; |
| uses TE-ADDR; | | uses TE-ADDR; |
| } | | } |
| container incoming-address-generic { | | container incoming-address-generic { |
| description | | description |
| "Incoming interface address"; | | "Incoming interface address"; |
| uses TE-ADDR; | | uses TE-ADDR; |
| } | | } |
| container s2l-convergence { | | container s2l-convergence { |
| description | | description |
| "TE LSP convergence related information"; | | "TE LSP convergence related information"; |
| uses TE-LSP-CONVERGENCE-INFO; | | uses TE-LSP-CONVERGENCE-INFO; |
| } | | } |
| container soft-preemption { | | container soft-preemption { |
| description | | description |
| "The soft preemption info for this LSP."; | | "The soft preemption info for this LSP."; |
| uses MPLS-TE-SOFT-PREEMPTION-LSP-INFO; | | uses MPLS-TE-SOFT-PREEMPTION-LSP-INFO; |
| } | | } |
| container gmpls-labels { | | container gmpls-labels { |
| description | | description |
| "GMPLS labels"; | | "GMPLS labels"; |
| uses MPLS-TE-MGMT-GMPLS-LABELS; | | uses MPLS-TE-MGMT-GMPLS-LABELS; |
| } | | } |
| container otn-s2l { | | container otn-s2l { |
| description | | description |
| "Otn S2L Information"; | | "Otn S2L Information"; |
| uses MPLS-TE-OTN-S2L-INFO; | | uses MPLS-TE-OTN-S2L-INFO; |
| } | | } |
| container head-end-bfd-info { | | container head-end-bfd-info { |
| description | | description |
| "The Head-end BFD info"; | | "The Head-end BFD info"; |
| uses MPLS-TE-HEAD-BFD-INFO; | | uses MPLS-TE-HEAD-BFD-INFO; |
| } | | } |
| container tail-end-bfd-info { | | container tail-end-bfd-info { |
| description | | description |
| "The Tail-end BFD info"; | | "The Tail-end BFD info"; |
| uses MPLS-TE-TAIL-BFD-INFO; | | uses MPLS-TE-TAIL-BFD-INFO; |
| } | | } |
| container srlg-collection { | | container srlg-collection { |
| description | | description |
| "SRLG-collection data"; | | "SRLG-collection data"; |
| uses TE-S2L-SRLG-COLLECT-INFO; | | uses TE-S2L-SRLG-COLLECT-INFO; |
| } | | } |
| container association { | | container association { |
| description | | description |
| "Association Object"; | | "Association Object"; |
| uses MPLS-TE-S2L-ASSOCIATION-OBJECT; | | uses MPLS-TE-S2L-ASSOCIATION-OBJECT; |
| } | | } |
| container protection { | | container protection { |
| description | | description |
| "Protection Object"; | | "Protection Object"; |
| uses MPLS-TE-S2L-PROTECTION-OBJECT; | | uses MPLS-TE-S2L-PROTECTION-OBJECT; |
| } | | } |
| container reverse-lsp-fec { | | container reverse-lsp-fec { |
| description | | description |
| "Reverse Associated Bidir LSP FEC"; | | "Reverse Associated Bidir LSP FEC"; |
| uses TE-LSP-FEC; | | uses TE-LSP-FEC; |
| } | | } |
| container reverse-tspec { | | container reverse-tspec { |
| description | | description |
| "The Reverse T spec info"; | | "The Reverse T spec info"; |
| uses BANDWIDTH-SPEC-BAG; | | uses BANDWIDTH-SPEC-BAG; |
| } | | } |
| container flex-info { | | container flex-info { |
| description | | description |
| "FlexLSP S2L Information"; | | "FlexLSP S2L Information"; |
| uses MPLS-TE-S2L-FLEX-INFO; | | uses MPLS-TE-S2L-FLEX-INFO; |
| } | | } |
| container lsp-wrap-info { | | container lsp-wrap-info { |
| description | | description |
| "Lsp Wrap Related information"; | | "Lsp Wrap Related information"; |
| uses TUNNEL-MIDPOINT-LSP-WRAP-INFO-BAG; | | uses TUNNEL-MIDPOINT-LSP-WRAP-INFO-BAG; |
| } | | } |
| container diversity-info { | | container diversity-info { |
| description | | description |
| "S2L Diversity Information"; | | "S2L Diversity Information"; |
| uses MPLS-TE-S2L-DIVERSITY-INFO; | | uses MPLS-TE-S2L-DIVERSITY-INFO; |
| } | | } |
| container accumulated-path-metrics { | | container accumulated-path-metrics { |
| description | | description |
| "Accumulated Path Metrics"; | | "Accumulated Path Metrics"; |
| uses MPLS-TE-PATH-METRICS; | | uses MPLS-TE-PATH-METRICS; |
| } | | } |
| container accumulated-reverse-path-metrics { | | container accumulated-reverse-path-metrics { |
| description | | description |
| "Accumulated Reverse Path Metrics"; | | "Accumulated Reverse Path Metrics"; |
| uses MPLS-TE-PATH-METRICS; | | uses MPLS-TE-PATH-METRICS; |
| } | | } |
| container delay-measurement { | | container delay-measurement { |
| description | | description |
| "S2L delay-measurement notification information"; | | "S2L delay-measurement notification information"; |
| uses MPLS-TE-S2L-DELAY-MEASUREMENT; | | uses MPLS-TE-S2L-DELAY-MEASUREMENT; |
| } | | } |
| leaf pcalc-area { | | leaf pcalc-area { |
| type string; | | type string; |
| description | | description |
| "IGP-area in which the S2L path was calculated"; | | "IGP-area in which the S2L path was calculated"; |
| } | | } |
| leaf is-expanded-ero { | | leaf is-expanded-ero { |
| type boolean; | | type boolean; |
| description | | description |
| "TRUE if this LSR expanded a loose path"; | | "TRUE if this LSR expanded a loose path"; |
| } | | } |
| leaf path-reeval-query-mid { | | leaf path-reeval-query-mid { |
| type uint32; | | type uint32; |
| description | | description |
| "Loose path reevaluation query received at | | "Loose path reevaluation query received at |
| mid-point"; | | mid-point"; |
| } | | } |
| leaf time-since-last-query-received-mid { | | leaf time-since-last-query-received-mid { |
| type uint32; | | type uint32; |
| description | | description |
| "Time since last reevaluation query received at | | "Time since last reevaluation query received at |
| mid-point"; | | mid-point"; |
| } | | } |
| leaf time-since-last-preferred-path-exists-send-mid { | | leaf time-since-last-preferred-path-exists-send-mid { |
| type uint32; | | type uint32; |
| description | | description |
| "Time since last preferred path exists msg send | | "Time since last preferred path exists msg send |
| from mid-point"; | | from mid-point"; |
| } | | } |
| leaf time-since-last-preferred-tree-exists-send-mid { | | leaf time-since-last-preferred-tree-exists-send-mid { |
| type uint32; | | type uint32; |
| description | | description |
| "Time since last preferred tree exists msg send | | "Time since last preferred tree exists msg send |
| from mid-point"; | | from mid-point"; |
| } | | } |
| leaf expanded-ero-area-id { | | leaf expanded-ero-area-id { |
| type string; | | type string; |
| description | | description |
| "Indicates the protocol and area used to find | | "Indicates the protocol and area used to find |
| Outgoing ERO"; | | Outgoing ERO"; |
| } | | } |
| leaf expanded-ero-affinity-bits { | | leaf expanded-ero-affinity-bits { |
| type uint32; | | type uint32; |
| description | | description |
| "The Outgoing ERO's affinity bits (colors)"; | | "The Outgoing ERO's affinity bits (colors)"; |
| } | | } |
| leaf expanded-ero-affinity-mask { | | leaf expanded-ero-affinity-mask { |
| type uint32; | | type uint32; |
| description | | description |
| "The Outgoing ERO's affinity mask (colors)"; | | "The Outgoing ERO's affinity mask (colors)"; |
| } | | } |
| leaf expanded-ero-metric-type { | | leaf expanded-ero-metric-type { |
| type Mpls-te-metric; | | type Mpls-te-metric; |
| description | | description |
| "The Outgoing ERO's selection metric"; | | "The Outgoing ERO's selection metric"; |
| } | | } |
| leaf expanded-ero-metric { | | leaf expanded-ero-metric { |
| type uint32; | | type uint32; |
| description | | description |
| "The metric value of the expanded path"; | | "The metric value of the expanded path"; |
| } | | } |
| leaf abr-auto-discovered { | | leaf abr-auto-discovered { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Next ABR auto discovered"; | | "Next ABR auto discovered"; |
| } | | } |
| leaf is-frr-enabled { | | leaf is-frr-enabled { |
| type boolean; | | type boolean; |
| description | | description |
| "FRR Enabled or Disabled"; | | "FRR Enabled or Disabled"; |
| } | | } |
| leaf is-node-protected { | | leaf is-node-protected { |
| type boolean; | | type boolean; |
| description | | description |
| "Node Protection Enabled or Disabled"; | | "Node Protection Enabled or Disabled"; |
| } | | } |
| leaf is-bandwidth-protect { | | leaf is-bandwidth-protect { |
| type boolean; | | type boolean; |
| description | | description |
| "BW Protection Enabled or Disabled"; | | "BW Protection Enabled or Disabled"; |
| } | | } |
| leaf path-rro-enabled { | | leaf path-rro-enabled { |
| type boolean; | | type boolean; |
| description | | description |
| "Path RRO Enabled or Disabled"; | | "Path RRO Enabled or Disabled"; |
| } | | } |
| leaf weight { | | leaf weight { |
| type uint64; | | type uint64; |
| description | | description |
| "The path's weight"; | | "The path's weight"; |
| } | | } |
| leaf reverse-weight { | | leaf reverse-weight { |
| type uint64; | | type uint64; |
| description | | description |
| "The reverse path weight"; | | "The reverse path weight"; |
| } | | } |
| leaf uptime { | | leaf uptime { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Time in seconds since the tunnel was up"; | | "Time in seconds since the tunnel was up"; |
| } | | } |
| leaf egress-interface { | | leaf egress-interface { |
| type string; | | type string; |
| description | | description |
| "Egress Interface"; | | "Egress Interface"; |
| } | | } |
| leaf egress-interface-state { | | leaf egress-interface-state { |
| type Te-controller-state; | | type Te-controller-state; |
| description | | description |
| "State of Outgoing Interface"; | | "State of Outgoing Interface"; |
| } | | } |
| leaf egress-interface-brief { | | leaf egress-interface-brief { |
| type string; | | type string; |
| description | | description |
| "Egress Interface in brief format"; | | "Egress Interface in brief format"; |
| } | | } |
| leaf ingress-interface { | | leaf ingress-interface { |
| type string; | | type string; |
| description | | description |
| "Ingress Interface"; | | "Ingress Interface"; |
| } | | } |
| leaf ingress-interface-state { | | leaf ingress-interface-state { |
| type Te-controller-state; | | type Te-controller-state; |
| description | | description |
| "State of Incoming Interface"; | | "State of Incoming Interface"; |
| } | | } |
| leaf ingress-interface-brief { | | leaf ingress-interface-brief { |
| type string; | | type string; |
| description | | description |
| "Ingress Interface in brief format"; | | "Ingress Interface in brief format"; |
| } | | } |
| leaf s2l-local-label { | | leaf s2l-local-label { |
| type uint32; | | type uint32; |
| description | | description |
| "Local label"; | | "Local label"; |
| } | | } |
| leaf s2l-out-label { | | leaf s2l-out-label { |
| type uint32; | | type uint32; |
| description | | description |
| "Outgoing label"; | | "Outgoing label"; |
| } | | } |
| leaf outbound-frr-state { | | leaf outbound-frr-state { |
| type Mpls-te-frr-state; | | type Mpls-te-frr-state; |
| description | | description |
| "Indicates outbound FRR state"; | | "Indicates outbound FRR state"; |
| } | | } |
| leaf frr-out-tunnel-interface { | | leaf frr-out-tunnel-interface { |
| type string; | | type string; |
| description | | description |
| "FRR out tunnel intface"; | | "FRR out tunnel intface"; |
| } | | } |
| leaf role { | | leaf role { |
| type Mpls-te-tunnel-role; | | type Mpls-te-tunnel-role; |
| description | | description |
| "Role of S2L"; | | "Role of S2L"; |
| } | | } |
| leaf signalling-status { | | leaf signalling-status { |
| type Mpls-te-tunnels-signaling-status; | | type Mpls-te-tunnels-signaling-status; |
| description | | description |
| "Signaling status"; | | "Signaling status"; |
| } | | } |
| leaf local-router-id { | | leaf local-router-id { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Local router id"; | | "Local router id"; |
| } | | } |
| leaf upstream-router-id { | | leaf upstream-router-id { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Upstream router id"; | | "Upstream router id"; |
| } | | } |
| leaf downstream-router-id { | | leaf downstream-router-id { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Downstream router id"; | | "Downstream router id"; |
| } | | } |
| leaf next-hop-address { | | leaf next-hop-address { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Next hop address"; | | "Next hop address"; |
| } | | } |
| leaf next-next-hop-address { | | leaf next-next-hop-address { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Next next hop address"; | | "Next next hop address"; |
| } | | } |
| leaf previous-hop-address { | | leaf previous-hop-address { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Previous hop address"; | | "Previous hop address"; |
| } | | } |
| leaf incoming-address { | | leaf incoming-address { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Incoming interface address"; | | "Incoming interface address"; |
| } | | } |
| leaf backup-tunnel-interface { | | leaf backup-tunnel-interface { |
| type xr:Interface-name; | | type xr:Interface-name; |
| description | | description |
| "Interface handle of the backup tunnel"; | | "Interface handle of the backup tunnel"; |
| } | | } |
| leaf node-hop-count { | | leaf node-hop-count { |
| type uint8; | | type uint8; |
| description | | description |
| "Hop count"; | | "Hop count"; |
| } | | } |
| leaf is-optical { | | leaf is-optical { |
| type boolean; | | type boolean; |
| description | | description |
| "Is Optical"; | | "Is Optical"; |
| } | | } |
| leaf s2l-reverse-ero-obj-present { | | leaf s2l-reverse-ero-obj-present { |
| type boolean; | | type boolean; |
| description | | description |
| " S2l Reverse ERO Object Present"; | | " S2l Reverse ERO Object Present"; |
| } | | } |
| leaf reverse-lsp-present { | | leaf reverse-lsp-present { |
| type boolean; | | type boolean; |
| description | | description |
| "Reverse Associated Bidir LSP Present"; | | "Reverse Associated Bidir LSP Present"; |
| } | | } |
| leaf reverse-lsp-connected { | | leaf reverse-lsp-connected { |
| type boolean; | | type boolean; |
| description | | description |
| "Reverse Associated Bidir LSP Connected"; | | "Reverse Associated Bidir LSP Connected"; |
| } | | } |
| leaf reverse-lsp-name { | | leaf reverse-lsp-name { |
| type string; | | type string; |
| description | | description |
| "Reverse Associated Bidir LSP Name"; | | "Reverse Associated Bidir LSP Name"; |
| } | | } |
| leaf s2l-reverse-tspec-obj-present { | | leaf s2l-reverse-tspec-obj-present { |
| type boolean; | | type boolean; |
| description | | description |
| " S2L Reverse TSpec Object Present"; | | " S2L Reverse TSpec Object Present"; |
| } | | } |
| leaf path-using-strict-spf { | | leaf path-using-strict-spf { |
| type boolean; | | type boolean; |
| description | | description |
| "Path is using Strict SPF"; | | "Path is using Strict SPF"; |
| } | | } |
| list s2l-reverse-lsp-sub-obj { | | list s2l-reverse-lsp-sub-obj { |
| description | | description |
| "Reverse LSP Sub Objects"; | | "Reverse LSP Sub Objects"; |
| leaf entry { | | leaf entry { |
| type uint8; | | type uint8; |
| description | | description |
| "Reverse LSP Sub Objects"; | | "Reverse LSP Sub Objects"; |
| } | | } |
| } | | } |
| list shared-risk-link-group { | | list shared-risk-link-group { |
| description | | description |
| "The S2L's excluded srlg groups"; | | "The S2L's excluded srlg groups"; |
| uses MPLS-SRLG-INFO; | | uses MPLS-SRLG-INFO; |
| } | | } |
| list out-ero { | | list out-ero { |
| description | | description |
| "Outgoing ERO for this S2L"; | | "Outgoing ERO for this S2L"; |
| uses RSVP-MGMT-ERO-SUBOBJ; | | uses RSVP-MGMT-ERO-SUBOBJ; |
| } | | } |
| list in-ero { | | list in-ero { |
| description | | description |
| "Incoming ERO for this S2L"; | | "Incoming ERO for this S2L"; |
| uses RSVP-MGMT-ERO-SUBOBJ; | | uses RSVP-MGMT-ERO-SUBOBJ; |
| } | | } |
| list path-rro { | | list path-rro { |
| description | | description |
| "Path RRO for this S2L"; | | "Path RRO for this S2L"; |
| uses RSVP-MGMT-RRO-SUBOBJ; | | uses RSVP-MGMT-RRO-SUBOBJ; |
| } | | } |
| list resv-rro { | | list resv-rro { |
| description | | description |
| "Resv RRO for this S2L"; | | "Resv RRO for this S2L"; |
| uses RSVP-MGMT-RRO-SUBOBJ; | | uses RSVP-MGMT-RRO-SUBOBJ; |
| } | | } |
| list path-affinity-array { | | list path-affinity-array { |
| description | | description |
| "Tunnel's Path hops with affinity"; | | "Tunnel's Path hops with affinity"; |
| uses TUNNEL-HOP-INFO; | | uses TUNNEL-HOP-INFO; |
| } | | } |
| list reverse-ero-in { | | list reverse-ero-in { |
| description | | description |
| " Reverse Incoming ERO for this S2L"; | | " Reverse Incoming ERO for this S2L"; |
| uses RSVP-MGMT-ERO-SUBOBJ; | | uses RSVP-MGMT-ERO-SUBOBJ; |
| } | | } |
| list s2l-segment-routing-path { | | list s2l-segment-routing-path { |
| description | | description |
| "Segment-Routing S2L path info"; | | "Segment-Routing S2L path info"; |
| uses TE-S2L-SR-PATH-HOP; | | uses TE-S2L-SR-PATH-HOP; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-P2MP-LSP { | | grouping MPLS-TE-P2MP-LSP { |
| description | | description |
| "A P2MP LSP"; | | "A P2MP LSP"; |
| container lsp-fec { | | container lsp-fec { |
| description | | description |
| "FEC for the LSP"; | | "FEC for the LSP"; |
| uses TE-LSP-FEC; | | uses TE-LSP-FEC; |
| } | | } |
| leaf signaled-name { | | leaf signaled-name { |
| type string; | | type string; |
| description | | description |
| "Signaled Name"; | | "Signaled Name"; |
| } | | } |
| leaf is-frr-failed { | | leaf is-frr-failed { |
| type boolean; | | type boolean; |
| description | | description |
| "P2MP LSP has FRR Failed"; | | "P2MP LSP has FRR Failed"; |
| } | | } |
| leaf frr-active-reason { | | leaf frr-active-reason { |
| type uint32; | | type uint32; |
| description | | description |
| "P2MP LSP FRR active reason"; | | "P2MP LSP FRR active reason"; |
| } | | } |
| leaf lsp-bandwidth { | | leaf lsp-bandwidth { |
| type uint32; | | type uint32; |
| description | | description |
| "P2MP LSP Bandwidth"; | | "P2MP LSP Bandwidth"; |
| } | | } |
| leaf lsp-setup-priority { | | leaf lsp-setup-priority { |
| type uint8; | | type uint8; |
| description | | description |
| "LSP setup priority"; | | "LSP setup priority"; |
| } | | } |
| leaf lsp-hold-priority { | | leaf lsp-hold-priority { |
| type uint8; | | type uint8; |
| description | | description |
| "LSP hold priority"; | | "LSP hold priority"; |
| } | | } |
| leaf lsp-bandwidth-type { | | leaf lsp-bandwidth-type { |
| type Mpls-te-bw-pool; | | type Mpls-te-bw-pool; |
| description | | description |
| "The LSP bandwidth type"; | | "The LSP bandwidth type"; |
| } | | } |
| leaf dste-class-match { | | leaf dste-class-match { |
| type boolean; | | type boolean; |
| description | | description |
| "Do the class type and priority match a DSTE | | "Do the class type and priority match a DSTE |
| class"; | | class"; |
| } | | } |
| leaf dste-class-index { | | leaf dste-class-index { |
| type uint8; | | type uint8; |
| description | | description |
| "Matching DSTE class index"; | | "Matching DSTE class index"; |
| } | | } |
| leaf type { | | leaf type { |
| type Mpls-te-lsp; | | type Mpls-te-lsp; |
| description | | description |
| "The type of this LSP"; | | "The type of this LSP"; |
| } | | } |
| leaf uptime { | | leaf uptime { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Time in seconds since the tunnel was up"; | | "Time in seconds since the tunnel was up"; |
| } | | } |
| leaf s2-ls-up { | | leaf s2-ls-up { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of connected S2Ls"; | | "Number of connected S2Ls"; |
| } | | } |
| leaf s2-ls-proceeding { | | leaf s2-ls-proceeding { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of proceeding S2Ls"; | | "Number of proceeding S2Ls"; |
| } | | } |
| leaf s2-ls-down { | | leaf s2-ls-down { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of down S2Ls"; | | "Number of down S2Ls"; |
| } | | } |
| leaf reoptimize-reason { | | leaf reoptimize-reason { |
| type Mpls-te-reopt-decision-reason; | | type Mpls-te-reopt-decision-reason; |
| description | | description |
| "Reason for re-optimization"; | | "Reason for re-optimization"; |
| } | | } |
| leaf reoptimize-trigger { | | leaf reoptimize-trigger { |
| type Mte-reopt-trigger; | | type Mte-reopt-trigger; |
| description | | description |
| "Re-optimize trigger"; | | "Re-optimize trigger"; |
| } | | } |
| leaf timer-left { | | leaf timer-left { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Time in seconds left to take next action if any"; | | "Time in seconds left to take next action if any"; |
| } | | } |
| leaf is-passive { | | leaf is-passive { |
| type boolean; | | type boolean; |
| description | | description |
| "True for passive tunnel"; | | "True for passive tunnel"; |
| } | | } |
| leaf is-interface { | | leaf is-interface { |
| type boolean; | | type boolean; |
| description | | description |
| "True for tunnel head"; | | "True for tunnel head"; |
| } | | } |
| leaf last-path-change { | | leaf last-path-change { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Time in seconds since the last path change"; | | "Time in seconds since the last path change"; |
| } | | } |
| leaf persistent-bytes { | | leaf persistent-bytes { |
| type uint64; | | type uint64; |
| units "byte"; | | units "byte"; |
| description | | description |
| "Persistent forwarding statistics for number of | | "Persistent forwarding statistics for number of |
| bytes. Clear counters will not reset the counter"; | | bytes. Clear counters will not reset the counter"; |
| } | | } |
| leaf persistent-packets { | | leaf persistent-packets { |
| type uint64; | | type uint64; |
| description | | description |
| "Persistent forwarding statistics for Number of | | "Persistent forwarding statistics for Number of |
| packets. Clear counters will not reset the | | packets. Clear counters will not reset the |
| counter"; | | counter"; |
| } | | } |
| leaf protection-role { | | leaf protection-role { |
| type Te-lsp-path-protection-role; | | type Te-lsp-path-protection-role; |
| description | | description |
| "Path Protection Role"; | | "Path Protection Role"; |
| } | | } |
| list s2l { | | list s2l { |
| description | | description |
| "array of S2L structures"; | | "array of S2L structures"; |
| uses MPLS-TE-P2MP-S2L; | | uses MPLS-TE-P2MP-S2L; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-P2MP-S2L-BRIEF { | | grouping MPLS-TE-P2MP-S2L-BRIEF { |
| description | | description |
| "A P2MP S2L"; | | "A P2MP S2L"; |
| container s2l-fec { | | container s2l-fec { |
| description | | description |
| "FEC for the S2L"; | | "FEC for the S2L"; |
| uses TE-S2L-FEC; | | uses TE-S2L-FEC; |
| } | | } |
| leaf uptime { | | leaf uptime { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Time in seconds since the S2L was up"; | | "Time in seconds since the S2L was up"; |
| } | | } |
| leaf egress-interface { | | leaf egress-interface { |
| type string; | | type string; |
| description | | description |
| "Egress Interface"; | | "Egress Interface"; |
| } | | } |
| leaf ingress-interface { | | leaf ingress-interface { |
| type string; | | type string; |
| description | | description |
| "Ingress Interface"; | | "Ingress Interface"; |
| } | | } |
| leaf role { | | leaf role { |
| type Mpls-te-tunnel-role; | | type Mpls-te-tunnel-role; |
| description | | description |
| "Role of S2L"; | | "Role of S2L"; |
| } | | } |
| leaf oper-state { | | leaf oper-state { |
| type boolean; | | type boolean; |
| description | | description |
| "Oper state of S2L"; | | "Oper state of S2L"; |
| } | | } |
| } | | } |
| | | |
| grouping MPLS-TE-P2MP-LSP-BRIEF { | | grouping MPLS-TE-P2MP-LSP-BRIEF { |
| description | | description |
| "A P2MP LSP"; | | "A P2MP LSP"; |
| container lsp-fec { | | container lsp-fec { |
| description | | description |
| "FEC for the LSP"; | | "FEC for the LSP"; |
| uses TE-LSP-FEC; | | uses TE-LSP-FEC; |
| } | | } |
| leaf signaled-name { | | leaf signaled-name { |
| type string; | | type string; |
| description | | description |
| "Signaled Name"; | | "Signaled Name"; |
| } | | } |
| leaf uptime { | | leaf uptime { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Time in seconds since the LSP was up"; | | "Time in seconds since the LSP was up"; |
| } | | } |
| list s2l { | | list s2l { |
| description | | description |
| "array of S2L structures"; | | "array of S2L structures"; |
| uses MPLS-TE-P2MP-S2L-BRIEF; | | uses MPLS-TE-P2MP-S2L-BRIEF; |
| } | | } |
| } | | } |
| | | |
| grouping TE-HW-OOR-STATS { | | grouping TE-HW-OOR-STATS { |
| description | | description |
| "HW OOR statistics"; | | "HW OOR statistics"; |
| leaf hw-oor-state { | | leaf hw-oor-state { |
| type Hw-oor-state; | | type Hw-oor-state; |
| description | | description |
| "The HW-OOR state that these statistics belong to"; | | "The HW-OOR state that these statistics belong to"; |
| } | | } |
| leaf transitions { | | leaf transitions { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of transitions to this state"; | | "Number of transitions to this state"; |
| } | | } |
| leaf node-protection-disable-number { | | leaf node-protection-disable-number { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of times this OOR state disabled node | | "Number of times this OOR state disabled node |
| protection assignment"; | | protection assignment"; |
| } | | } |
| leaf rejected-ls-ps-number { | | leaf rejected-ls-ps-number { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of LSPs that were rejected in this state"; | | "Number of LSPs that were rejected in this state"; |
| } | | } |
| leaf accepted-ls-ps-number { | | leaf accepted-ls-ps-number { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of LSPs that were accepted in this state"; | | "Number of LSPs that were accepted in this state"; |
| } | | } |
| leaf accepted-reopt-ls-ps-number { | | leaf accepted-reopt-ls-ps-number { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of Reoptimize LSPs that were accepted in | | "Number of Reoptimize LSPs that were accepted in |
| this state"; | | this state"; |
| } | | } |
| leaf rejected-reopt-ls-ps-number { | | leaf rejected-reopt-ls-ps-number { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of Reoptimize LSPs that were rejected in | | "Number of Reoptimize LSPs that were rejected in |
| this state"; | | this state"; |
| } | | } |
| } | | } |
| | | |
| grouping TE-HW-OOR-STATE-INFO { | | grouping TE-HW-OOR-STATE-INFO { |
| description | | description |
| "HW OOR State Information"; | | "HW OOR State Information"; |
| container statistics { | | container statistics { |
| description | | description |
| "NPU HW OOR Statistics per state"; | | "NPU HW OOR Statistics per state"; |
| uses TE-HW-OOR-STATS; | | uses TE-HW-OOR-STATS; |
| } | | } |
| leaf hw-oor-state { | | leaf hw-oor-state { |
| type Hw-oor-state; | | type Hw-oor-state; |
| description | | description |
| "The HW-OOR state that this information belong to"; | | "The HW-OOR state that this information belong to"; |
| } | | } |
| leaf te-metric-penalty { | | leaf te-metric-penalty { |
| type uint32; | | type uint32; |
| description | | description |
| "The TE metric penalty when the link is in this | | "The TE metric penalty when the link is in this |
| NPU HW OOR state"; | | NPU HW OOR state"; |
| } | | } |
| leaf available-bw-percentage { | | leaf available-bw-percentage { |
| type uint32; | | type uint32; |
| units "percentage"; | | units "percentage"; |
| description | | description |
| "The flooded percentage of available bandwidth | | "The flooded percentage of available bandwidth |
| advertized when the link is in this NPU HW OOR | | advertized when the link is in this NPU HW OOR |
| state"; | | state"; |
| } | | } |
| leaf node-protection-disable { | | leaf node-protection-disable { |
| type boolean; | | type boolean; |
| description | | description |
| "Disable FRR node protection when the link is in | | "Disable FRR node protection when the link is in |
| this NPU HW OOR state"; | | this NPU HW OOR state"; |
| } | | } |
| leaf transition-duration { | | leaf transition-duration { |
| type uint32; | | type uint32; |
| units "minute"; | | units "minute"; |
| description | | description |
| "Recovery in minutes after the green OOR state is | | "Recovery in minutes after the green OOR state is |
| entered."; | | entered."; |
| } | | } |
| leaf minimum-lsp-bandwidth { | | leaf minimum-lsp-bandwidth { |
| type uint32; | | type uint32; |
| description | | description |
| "Minimum LSP bandwidth so the LSP is admitted | | "Minimum LSP bandwidth so the LSP is admitted |
| when the link is in this NPU HW OOR state"; | | when the link is in this NPU HW OOR state"; |
| } | | } |
| leaf accept-reopt { | | leaf accept-reopt { |
| type boolean; | | type boolean; |
| description | | description |
| "Make-before-break is allowed for LSPs | | "Make-before-break is allowed for LSPs |
| reoptimizing over the same link in the NPU HW | | reoptimizing over the same link in the NPU HW |
| OOR state"; | | OOR state"; |
| } | | } |
| } | | } |
| | | |
| grouping TE-HW-OOR-INFO { | | grouping TE-HW-OOR-INFO { |
| description | | description |
| "NPU HW OOR parameters for MPLS-TE"; | | "NPU HW OOR parameters for MPLS-TE"; |
| list hardware-out-of-resources-state { | | list hardware-out-of-resources-state { |
| max-elements "3"; | | max-elements "3"; |
| description | | description |
| "Array of NPU HW OOR info per state"; | | "Array of NPU HW OOR info per state"; |
| uses TE-HW-OOR-STATE-INFO; | | uses TE-HW-OOR-STATE-INFO; |
| } | | } |
| } | | } |
| } | | } |